The Tor Browser: services/sync/modules/addonsreconciler.js@6474c204b198 (annotated)

services/sync/modules/addonsreconciler.js@6474c204b198 (annotated)

services/sync/modules/addonsreconciler.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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 file contains middleware to reconcile state of AddonManager for
  * purposes of tracking events for Sync. The content in this file exists
  * because AddonManager does not have a getChangesSinceX() API and adding
  * that functionality properly was deemed too time-consuming at the time
  * add-on sync was originally written. If/when AddonManager adds this API,
  * this file can go away and the add-ons engine can be rewritten to use it.
  *
  * It was decided to have this tracking functionality exist in a separate
  * standalone file so it could be more easily understood, tested, and
  * hopefully ported.
  */
 "use strict";
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/Log.jsm");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://gre/modules/AddonManager.jsm");
 const DEFAULT_STATE_FILE = "addonsreconciler";
 this.CHANGE_INSTALLED   = 1;
 this.CHANGE_UNINSTALLED = 2;
 this.CHANGE_ENABLED     = 3;
 this.CHANGE_DISABLED    = 4;
 this.EXPORTED_SYMBOLS = ["AddonsReconciler", "CHANGE_INSTALLED",
                          "CHANGE_UNINSTALLED", "CHANGE_ENABLED",
                          "CHANGE_DISABLED"];
 /**
  * Maintains state of add-ons.
  *
  * State is maintained in 2 data structures, an object mapping add-on IDs
  * to metadata and an array of changes over time. The object mapping can be
  * thought of as a minimal copy of data from AddonManager which is needed for
  * Sync. The array is effectively a log of changes over time.
  *
  * The data structures are persisted to disk by serializing to a JSON file in
  * the current profile. The data structures are updated by 2 mechanisms. First,
  * they can be refreshed from the global state of the AddonManager. This is a
  * sure-fire way of ensuring the reconciler is up to date. Second, the
  * reconciler adds itself as an AddonManager listener. When it receives change
  * notifications, it updates its internal state incrementally.
  *
  * The internal state is persisted to a JSON file in the profile directory.
  *
  * An instance of this is bound to an AddonsEngine instance. In reality, it
  * likely exists as a singleton. To AddonsEngine, it functions as a store and
  * an entity which emits events for tracking.
  *
  * The usage pattern for instances of this class is:
  *
  *   let reconciler = new AddonsReconciler();
  *   reconciler.loadState(null, function(error) { ... });
  *
  *   // At this point, your instance should be ready to use.
  *
  * When you are finished with the instance, please call:
  *
  *   reconciler.stopListening();
  *   reconciler.saveState(...);
  *
  * There are 2 classes of listeners in the AddonManager: AddonListener and
  * InstallListener. This class is a listener for both (member functions just
  * get called directly).
  *
  * When an add-on is installed, listeners are called in the following order:
  *
  *  IL.onInstallStarted, AL.onInstalling, IL.onInstallEnded, AL.onInstalled
  *
  * For non-restartless add-ons, an application restart may occur between
  * IL.onInstallEnded and AL.onInstalled. Unfortunately, Sync likely will
  * not be loaded when AL.onInstalled is fired shortly after application
  * start, so it won't see this event. Therefore, for add-ons requiring a
  * restart, Sync treats the IL.onInstallEnded event as good enough to
  * indicate an install. For restartless add-ons, Sync assumes AL.onInstalled
  * will follow shortly after IL.onInstallEnded and thus it ignores
  * IL.onInstallEnded.
  *
  * The listeners can also see events related to the download of the add-on.
  * This class isn't interested in those. However, there are failure events,
  * IL.onDownloadFailed and IL.onDownloadCanceled which get called if a
  * download doesn't complete successfully.
  *
  * For uninstalls, we see AL.onUninstalling then AL.onUninstalled. Like
  * installs, the events could be separated by an application restart and Sync
  * may not see the onUninstalled event. Again, if we require a restart, we
  * react to onUninstalling. If not, we assume we'll get onUninstalled.
  *
  * Enabling and disabling work by sending:
  *
  *   AL.onEnabling, AL.onEnabled
  *   AL.onDisabling, AL.onDisabled
  *
  * Again, they may be separated by a restart, so we heed the requiresRestart
  * flag.
  *
  * Actions can be undone. All undoable actions notify the same
  * AL.onOperationCancelled event. We treat this event like any other.
  *
  * Restartless add-ons have interesting behavior during uninstall. These
  * add-ons are first disabled then they are actually uninstalled. So, we will
  * see AL.onDisabling and AL.onDisabled. The onUninstalling and onUninstalled
  * events only come after the Addon Manager is closed or another view is
  * switched to. In the case of Sync performing the uninstall, the uninstall
  * events will occur immediately. However, we still see disabling events and
  * heed them like they were normal. In the end, the state is proper.
  */
 this.AddonsReconciler = function AddonsReconciler() {
   this._log = Log.repository.getLogger("Sync.AddonsReconciler");
   let level = Svc.Prefs.get("log.logger.addonsreconciler", "Debug");
   this._log.level = Log.Level[level];
   Svc.Obs.add("xpcom-shutdown", this.stopListening, this);
 };
 AddonsReconciler.prototype = {
   /** Flag indicating whether we are listening to AddonManager events. */
   _listening: false,
   /**
    * Whether state has been loaded from a file.
    *
    * State is loaded on demand if an operation requires it.
    */
   _stateLoaded: false,
   /**
    * Define this as false if the reconciler should not persist state
    * to disk when handling events.
    *
    * This allows test code to avoid spinning to write during observer
    * notifications and xpcom shutdown, which appears to cause hangs on WinXP
    * (Bug 873861).
    */
   _shouldPersist: true,
   /** Log logger instance */
   _log: null,
   /**
    * Container for add-on metadata.
    *
    * Keys are add-on IDs. Values are objects which describe the state of the
    * add-on. This is a minimal mirror of data that can be queried from
    * AddonManager. In some cases, we retain data longer than AddonManager.
    */
   _addons: {},
   /**
    * List of add-on changes over time.
    *
    * Each element is an array of [time, change, id].
    */
   _changes: [],
   /**
    * Objects subscribed to changes made to this instance.
    */
   _listeners: [],
   /**
    * Accessor for add-ons in this object.
    *
    * Returns an object mapping add-on IDs to objects containing metadata.
    */
   get addons() {
     this._ensureStateLoaded();
     return this._addons;
   },
   /**
    * Load reconciler state from a file.
    *
    * The path is relative to the weave directory in the profile. If no
    * path is given, the default one is used.
    *
    * If the file does not exist or there was an error parsing the file, the
    * state will be transparently defined as empty.
    *
    * @param path
    *        Path to load. ".json" is appended automatically. If not defined,
    *        a default path will be consulted.
    * @param callback
    *        Callback to be executed upon file load. The callback receives a
    *        truthy error argument signifying whether an error occurred and a
    *        boolean indicating whether data was loaded.
    */
   loadState: function loadState(path, callback) {
     let file = path || DEFAULT_STATE_FILE;
     Utils.jsonLoad(file, this, function(json) {
       this._addons = {};
       this._changes = [];
       if (!json) {
         this._log.debug("No data seen in loaded file: " + file);
         if (callback) {
           callback(null, false);
         }
         return;
       }
       let version = json.version;
       if (!version || version != 1) {
         this._log.error("Could not load JSON file because version not " +
                         "supported: " + version);
         if (callback) {
           callback(null, false);
         }
         return;
       }
       this._addons = json.addons;
       for each (let record in this._addons) {
         record.modified = new Date(record.modified);
       }
       for each (let [time, change, id] in json.changes) {
         this._changes.push([new Date(time), change, id]);
       }
       if (callback) {
         callback(null, true);
       }
     });
   },
   /**
    * Saves the current state to a file in the local profile.
    *
    * @param  path
    *         String path in profile to save to. If not defined, the default
    *         will be used.
    * @param  callback
    *         Function to be invoked on save completion. No parameters will be
    *         passed to callback.
    */
   saveState: function saveState(path, callback) {
     let file = path || DEFAULT_STATE_FILE;
     let state = {version: 1, addons: {}, changes: []};
     for (let [id, record] in Iterator(this._addons)) {
       state.addons[id] = {};
       for (let [k, v] in Iterator(record)) {
         if (k == "modified") {
           state.addons[id][k] = v.getTime();
         }
         else {
           state.addons[id][k] = v;
         }
       }
     }
     for each (let [time, change, id] in this._changes) {
       state.changes.push([time.getTime(), change, id]);
     }
     this._log.info("Saving reconciler state to file: " + file);
     Utils.jsonSave(file, this, state, callback);
   },
   /**
    * Registers a change listener with this instance.
    *
    * Change listeners are called every time a change is recorded. The listener
    * is an object with the function "changeListener" that takes 3 arguments,
    * the Date at which the change happened, the type of change (a CHANGE_*
    * constant), and the add-on state object reflecting the current state of
    * the add-on at the time of the change.
    *
    * @param listener
    *        Object containing changeListener function.
    */
   addChangeListener: function addChangeListener(listener) {
     if (this._listeners.indexOf(listener) == -1) {
       this._log.debug("Adding change listener.");
       this._listeners.push(listener);
     }
   },
   /**
    * Removes a previously-installed change listener from the instance.
    *
    * @param listener
    *        Listener instance to remove.
    */
   removeChangeListener: function removeChangeListener(listener) {
     this._listeners = this._listeners.filter(function(element) {
       if (element == listener) {
         this._log.debug("Removing change listener.");
         return false;
       } else {
         return true;
       }
     }.bind(this));
   },
   /**
    * Tells the instance to start listening for AddonManager changes.
    *
    * This is typically called automatically when Sync is loaded.
    */
   startListening: function startListening() {
     if (this._listening) {
       return;
     }
     this._log.info("Registering as Add-on Manager listener.");
     AddonManager.addAddonListener(this);
     AddonManager.addInstallListener(this);
     this._listening = true;
   },
   /**
    * Tells the instance to stop listening for AddonManager changes.
    *
    * The reconciler should always be listening. This should only be called when
    * the instance is being destroyed.
    *
    * This function will get called automatically on XPCOM shutdown. However, it
    * is a best practice to call it yourself.
    */
   stopListening: function stopListening() {
     if (!this._listening) {
       return;
     }
     this._log.debug("Stopping listening and removing AddonManager listeners.");
     AddonManager.removeInstallListener(this);
     AddonManager.removeAddonListener(this);
     this._listening = false;
   },
   /**
    * Refreshes the global state of add-ons by querying the AddonManager.
    */
   refreshGlobalState: function refreshGlobalState(callback) {
     this._log.info("Refreshing global state from AddonManager.");
     this._ensureStateLoaded();
     let installs;
     AddonManager.getAllAddons(function (addons) {
       let ids = {};
       for each (let addon in addons) {
         ids[addon.id] = true;
         this.rectifyStateFromAddon(addon);
       }
       // Look for locally-defined add-ons that no longer exist and update their
       // record.
       for (let [id, addon] in Iterator(this._addons)) {
         if (id in ids) {
           continue;
         }
         // If the id isn't in ids, it means that the add-on has been deleted or
         // the add-on is in the process of being installed. We detect the
         // latter by seeing if an AddonInstall is found for this add-on.
         if (!installs) {
           let cb = Async.makeSyncCallback();
           AddonManager.getAllInstalls(cb);
           installs = Async.waitForSyncCallback(cb);
         }
         let installFound = false;
         for each (let install in installs) {
           if (install.addon && install.addon.id == id &&
               install.state == AddonManager.STATE_INSTALLED) {
             installFound = true;
             break;
           }
         }
         if (installFound) {
           continue;
         }
         if (addon.installed) {
           addon.installed = false;
           this._log.debug("Adding change because add-on not present in " +
                           "Add-on Manager: " + id);
           this._addChange(new Date(), CHANGE_UNINSTALLED, addon);
         }
       }
       // See note for _shouldPersist.
       if (this._shouldPersist) {
         this.saveState(null, callback);
       } else {
         callback();
       }
     }.bind(this));
   },
   /**
    * Rectifies the state of an add-on from an Addon instance.
    *
    * This basically says "given an Addon instance, assume it is truth and
    * apply changes to the local state to reflect it."
    *
    * This function could result in change listeners being called if the local
    * state differs from the passed add-on's state.
    *
    * @param addon
    *        Addon instance being updated.
    */
   rectifyStateFromAddon: function rectifyStateFromAddon(addon) {
     this._log.debug("Rectifying state for addon: " + addon.id);
     this._ensureStateLoaded();
     let id = addon.id;
     let enabled = !addon.userDisabled;
     let guid = addon.syncGUID;
     let now = new Date();
     if (!(id in this._addons)) {
       let record = {
         id: id,
         guid: guid,
         enabled: enabled,
         installed: true,
         modified: now,
         type: addon.type,
         scope: addon.scope,
         foreignInstall: addon.foreignInstall
       };
       this._addons[id] = record;
       this._log.debug("Adding change because add-on not present locally: " +
                       id);
       this._addChange(now, CHANGE_INSTALLED, record);
       return;
     }
     let record = this._addons[id];
     if (!record.installed) {
       // It is possible the record is marked as uninstalled because an
       // uninstall is pending.
       if (!(addon.pendingOperations & AddonManager.PENDING_UNINSTALL)) {
         record.installed = true;
         record.modified = now;
       }
     }
     if (record.enabled != enabled) {
       record.enabled = enabled;
       record.modified = now;
       let change = enabled ? CHANGE_ENABLED : CHANGE_DISABLED;
       this._log.debug("Adding change because enabled state changed: " + id);
       this._addChange(new Date(), change, record);
     }
     if (record.guid != guid) {
       record.guid = guid;
       // We don't record a change because the Sync engine rectifies this on its
       // own. This is tightly coupled with Sync. If this code is ever lifted
       // outside of Sync, this exception should likely be removed.
     }
   },
   /**
    * Record a change in add-on state.
    *
    * @param date
    *        Date at which the change occurred.
    * @param change
    *        The type of the change. A CHANGE_* constant.
    * @param state
    *        The new state of the add-on. From this.addons.
    */
   _addChange: function _addChange(date, change, state) {
     this._log.info("Change recorded for " + state.id);
     this._changes.push([date, change, state.id]);
     for each (let listener in this._listeners) {
       try {
         listener.changeListener.call(listener, date, change, state);
       } catch (ex) {
         this._log.warn("Exception calling change listener: " +
                        Utils.exceptionStr(ex));
       }
     }
   },
   /**
    * Obtain the set of changes to add-ons since the date passed.
    *
    * This will return an array of arrays. Each entry in the array has the
    * elements [date, change_type, id], where
    *
    *   date - Date instance representing when the change occurred.
    *   change_type - One of CHANGE_* constants.
    *   id - ID of add-on that changed.
    */
   getChangesSinceDate: function getChangesSinceDate(date) {
     this._ensureStateLoaded();
     let length = this._changes.length;
     for (let i = 0; i < length; i++) {
       if (this._changes[i][0] >= date) {
         return this._changes.slice(i);
       }
     }
     return [];
   },
   /**
    * Prunes all recorded changes from before the specified Date.
    *
    * @param date
    *        Entries older than this Date will be removed.
    */
   pruneChangesBeforeDate: function pruneChangesBeforeDate(date) {
     this._ensureStateLoaded();
     this._changes = this._changes.filter(function test_age(change) {
       return change[0] >= date;
     });
   },
   /**
    * Obtains the set of all known Sync GUIDs for add-ons.
    *
    * @return Object with guids as keys and values of true.
    */
   getAllSyncGUIDs: function getAllSyncGUIDs() {
     let result = {};
     for (let id in this.addons) {
       result[id] = true;
     }
     return result;
   },
   /**
    * Obtain the add-on state record for an add-on by Sync GUID.
    *
    * If the add-on could not be found, returns null.
    *
    * @param  guid
    *         Sync GUID of add-on to retrieve.
    * @return Object on success on null on failure.
    */
   getAddonStateFromSyncGUID: function getAddonStateFromSyncGUID(guid) {
     for each (let addon in this.addons) {
       if (addon.guid == guid) {
         return addon;
       }
     }
     return null;
   },
   /**
    * Ensures that state is loaded before continuing.
    *
    * This is called internally by anything that accesses the internal data
    * structures. It effectively just-in-time loads serialized state.
    */
   _ensureStateLoaded: function _ensureStateLoaded() {
     if (this._stateLoaded) {
       return;
     }
     let cb = Async.makeSpinningCallback();
     this.loadState(null, cb);
     cb.wait();
     this._stateLoaded = true;
   },
   /**
    * Handler that is invoked as part of the AddonManager listeners.
    */
   _handleListener: function _handlerListener(action, addon, requiresRestart) {
     // Since this is called as an observer, we explicitly trap errors and
     // log them to ourselves so we don't see errors reported elsewhere.
     try {
       let id = addon.id;
       this._log.debug("Add-on change: " + action + " to " + id);
       // We assume that every event for non-restartless add-ons is
       // followed by another event and that this follow-up event is the most
       // appropriate to react to. Currently we ignore onEnabling, onDisabling,
       // and onUninstalling for non-restartless add-ons.
       if (requiresRestart === false) {
         this._log.debug("Ignoring " + action + " for restartless add-on.");
         return;
       }
       switch (action) {
         case "onEnabling":
         case "onEnabled":
         case "onDisabling":
         case "onDisabled":
         case "onInstalled":
         case "onInstallEnded":
         case "onOperationCancelled":
           this.rectifyStateFromAddon(addon);
           break;
         case "onUninstalling":
         case "onUninstalled":
           let id = addon.id;
           let addons = this.addons;
           if (id in addons) {
             let now = new Date();
             let record = addons[id];
             record.installed = false;
             record.modified = now;
             this._log.debug("Adding change because of uninstall listener: " +
                             id);
             this._addChange(now, CHANGE_UNINSTALLED, record);
           }
       }
       // See note for _shouldPersist.
       if (this._shouldPersist) {
         let cb = Async.makeSpinningCallback();
         this.saveState(null, cb);
         cb.wait();
       }
     }
     catch (ex) {
       this._log.warn("Exception: " + Utils.exceptionStr(ex));
     }
   },
   // AddonListeners
   onEnabling: function onEnabling(addon, requiresRestart) {
     this._handleListener("onEnabling", addon, requiresRestart);
   },
   onEnabled: function onEnabled(addon) {
     this._handleListener("onEnabled", addon);
   },
   onDisabling: function onDisabling(addon, requiresRestart) {
     this._handleListener("onDisabling", addon, requiresRestart);
   },
   onDisabled: function onDisabled(addon) {
     this._handleListener("onDisabled", addon);
   },
   onInstalling: function onInstalling(addon, requiresRestart) {
     this._handleListener("onInstalling", addon, requiresRestart);
   },
   onInstalled: function onInstalled(addon) {
     this._handleListener("onInstalled", addon);
   },
   onUninstalling: function onUninstalling(addon, requiresRestart) {
     this._handleListener("onUninstalling", addon, requiresRestart);
   },
   onUninstalled: function onUninstalled(addon) {
     this._handleListener("onUninstalled", addon);
   },
   onOperationCancelled: function onOperationCancelled(addon) {
     this._handleListener("onOperationCancelled", addon);
   },
   // InstallListeners
   onInstallEnded: function onInstallEnded(install, addon) {
     this._handleListener("onInstallEnded", addon);
   }
 };