The Tor Browser: services/sync/modules/engines/forms.js@b8a032363ba2 (annotated)

services/sync/modules/engines/forms.js@b8a032363ba2 (annotated)

services/sync/modules/engines/forms.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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;
   },
 };