The Tor Browser: comparison services/sync/modules/engines/forms.js

comparison: services/sync/modules/engines/forms.js

services/sync/modules/engines/forms.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:1bceaa48bd04
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+this.EXPORTED_SYMBOLS = ['FormEngine', 'FormRec'];
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://services-sync/engines.js");
+Cu.import("resource://services-sync/record.js");
+Cu.import("resource://services-common/async.js");
+Cu.import("resource://services-sync/util.js");
+Cu.import("resource://services-sync/constants.js");
+Cu.import("resource://gre/modules/Log.jsm");
+const FORMS_TTL = 5184000; // 60 days
+this.FormRec = function FormRec(collection, id) {
+CryptoWrapper.call(this, collection, id);
+}
+FormRec.prototype = {
+__proto__: CryptoWrapper.prototype,
+_logName: "Sync.Record.Form",
+ttl: FORMS_TTL
+};
+Utils.deferGetSet(FormRec, "cleartext", ["name", "value"]);
+let FormWrapper = {
+_log: Log.repository.getLogger("Sync.Engine.Forms"),
+_getEntryCols: ["fieldname", "value"],
+_guidCols:     ["guid"],
+// Do a "sync" search by spinning the event loop until it completes.
+_searchSpinningly: function(terms, searchData) {
+let results = [];
+let cb = Async.makeSpinningCallback();
+let callbacks = {
+handleResult: function(result) {
+results.push(result);
+},
+handleCompletion: function(reason) {
+cb(null, results);
+}
+};
+Svc.FormHistory.search(terms, searchData, callbacks);
+return cb.wait();
+},
+_updateSpinningly: function(changes) {
+if (!Svc.FormHistory.enabled) {
+return; // update isn't going to do anything.
+}
+let cb = Async.makeSpinningCallback();
+let callbacks = {
+handleCompletion: function(reason) {
+cb();
+}
+};
+Svc.FormHistory.update(changes, callbacks);
+return cb.wait();
+},
+getEntry: function (guid) {
+let results = this._searchSpinningly(this._getEntryCols, {guid: guid});
+if (!results.length) {
+return null;
+}
+return {name: results[0].fieldname, value: results[0].value};
+},
+getGUID: function (name, value) {
+// Query for the provided entry.
+let query = { fieldname: name, value: value };
+let results = this._searchSpinningly(this._guidCols, query);
+return results.length ? results[0].guid : null;
+},
+hasGUID: function (guid) {
+// We could probably use a count function here, but searchSpinningly exists...
+return this._searchSpinningly(this._guidCols, {guid: guid}).length != 0;
+},
+replaceGUID: function (oldGUID, newGUID) {
+let changes = {
+op: "update",
+guid: oldGUID,
+newGuid: newGUID,
+}
+this._updateSpinningly(changes);
+}
+};
+this.FormEngine = function FormEngine(service) {
+SyncEngine.call(this, "Forms", service);
+}
+FormEngine.prototype = {
+__proto__: SyncEngine.prototype,
+_storeObj: FormStore,
+_trackerObj: FormTracker,
+_recordObj: FormRec,
+applyIncomingBatchSize: FORMS_STORE_BATCH_SIZE,
+get prefName() "history",
+_findDupe: function _findDupe(item) {
+return FormWrapper.getGUID(item.name, item.value);
+}
+};
+function FormStore(name, engine) {
+Store.call(this, name, engine);
+}
+FormStore.prototype = {
+__proto__: Store.prototype,
+_processChange: function (change) {
+// If this._changes is defined, then we are applying a batch, so we
+// can defer it.
+if (this._changes) {
+this._changes.push(change);
+return;
+}
+// Otherwise we must handle the change synchronously, right now.
+FormWrapper._updateSpinningly(change);
+},
+applyIncomingBatch: function (records) {
+// We collect all the changes to be made then apply them all at once.
+this._changes = [];
+let failures = Store.prototype.applyIncomingBatch.call(this, records);
+if (this._changes.length) {
+FormWrapper._updateSpinningly(this._changes);
+}
+delete this._changes;
+return failures;
+},
+getAllIDs: function () {
+let results = FormWrapper._searchSpinningly(["guid"], [])
+let guids = {};
+for (let result of results) {
+guids[result.guid] = true;
+}
+return guids;
+},
+changeItemID: function (oldID, newID) {
+FormWrapper.replaceGUID(oldID, newID);
+},
+itemExists: function (id) {
+return FormWrapper.hasGUID(id);
+},
+createRecord: function (id, collection) {
+let record = new FormRec(collection, id);
+let entry = FormWrapper.getEntry(id);
+if (entry != null) {
+record.name = entry.name;
+record.value = entry.value;
+} else {
+record.deleted = true;
+}
+return record;
+},
+create: function (record) {
+this._log.trace("Adding form record for " + record.name);
+let change = {
+op: "add",
+fieldname: record.name,
+value: record.value
+};
+this._processChange(change);
+},
+remove: function (record) {
+this._log.trace("Removing form record: " + record.id);
+let change = {
+op: "remove",
+guid: record.id
+};
+this._processChange(change);
+},
+update: function (record) {
+this._log.trace("Ignoring form record update request!");
+},
+wipe: function () {
+let change = {
+op: "remove"
+};
+FormWrapper._updateSpinningly(change);
+}
+};
+function FormTracker(name, engine) {
+Tracker.call(this, name, engine);
+}
+FormTracker.prototype = {
+__proto__: Tracker.prototype,
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIObserver,
+Ci.nsISupportsWeakReference]),
+startTracking: function() {
+Svc.Obs.add("satchel-storage-changed", this);
+},
+stopTracking: function() {
+Svc.Obs.remove("satchel-storage-changed", this);
+},
+observe: function (subject, topic, data) {
+Tracker.prototype.observe.call(this, subject, topic, data);
+switch (topic) {
+case "satchel-storage-changed":
+if (data == "formhistory-add" || data == "formhistory-remove") {
+let guid = subject.QueryInterface(Ci.nsISupportsString).toString();
+this.trackEntry(guid);
+}
+break;
+}
+},
+trackEntry: function (guid) {
+this.addChangedID(guid);
+this.score += SCORE_INCREMENT_MEDIUM;
+},
+};