The Tor Browser: toolkit/mozapps/extensions/AddonManager.jsm@129ffea94266 (annotated)

toolkit/mozapps/extensions/AddonManager.jsm@129ffea94266 (annotated)

toolkit/mozapps/extensions/AddonManager.jsm

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* 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/. */
 "use strict";
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 // Cannot use Services.appinfo here, or else xpcshell-tests will blow up, as
 // most tests later register different nsIAppInfo implementations, which
 // wouldn't be reflected in Services.appinfo anymore, as the lazy getter
 // underlying it would have been initialized if we used it here.
 if ("@mozilla.org/xre/app-info;1" in Cc) {
   let runtime = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime);
   if (runtime.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT) {
     // Refuse to run in child processes.
     throw new Error("You cannot use the AddonManager in child processes!");
   }
 }
 const PREF_BLOCKLIST_PINGCOUNTVERSION = "extensions.blocklist.pingCountVersion";
 const PREF_DEFAULT_PROVIDERS_ENABLED  = "extensions.defaultProviders.enabled";
 const PREF_EM_UPDATE_ENABLED          = "extensions.update.enabled";
 const PREF_EM_LAST_APP_VERSION        = "extensions.lastAppVersion";
 const PREF_EM_LAST_PLATFORM_VERSION   = "extensions.lastPlatformVersion";
 const PREF_EM_AUTOUPDATE_DEFAULT      = "extensions.update.autoUpdateDefault";
 const PREF_EM_STRICT_COMPATIBILITY    = "extensions.strictCompatibility";
 const PREF_EM_CHECK_UPDATE_SECURITY   = "extensions.checkUpdateSecurity";
 const PREF_EM_UPDATE_BACKGROUND_URL   = "extensions.update.background.url";
 const PREF_APP_UPDATE_ENABLED         = "app.update.enabled";
 const PREF_APP_UPDATE_AUTO            = "app.update.auto";
 const PREF_EM_HOTFIX_ID               = "extensions.hotfix.id";
 const PREF_EM_HOTFIX_LASTVERSION      = "extensions.hotfix.lastVersion";
 const PREF_EM_HOTFIX_URL              = "extensions.hotfix.url";
 const PREF_EM_CERT_CHECKATTRIBUTES    = "extensions.hotfix.cert.checkAttributes";
 const PREF_EM_HOTFIX_CERTS            = "extensions.hotfix.certs.";
 const PREF_MATCH_OS_LOCALE            = "intl.locale.matchOS";
 const PREF_SELECTED_LOCALE            = "general.useragent.locale";
 const UNKNOWN_XPCOM_ABI               = "unknownABI";
 const UPDATE_REQUEST_VERSION          = 2;
 const CATEGORY_UPDATE_PARAMS          = "extension-update-params";
 const XMLURI_BLOCKLIST                = "http://www.mozilla.org/2006/addons-blocklist";
 const KEY_PROFILEDIR                  = "ProfD";
 const KEY_APPDIR                      = "XCurProcD";
 const FILE_BLOCKLIST                  = "blocklist.xml";
 const BRANCH_REGEXP                   = /^([^\.]+\.[0-9]+[a-z]*).*/gi;
 const PREF_EM_CHECK_COMPATIBILITY_BASE = "extensions.checkCompatibility";
 #ifdef MOZ_COMPATIBILITY_NIGHTLY
 var PREF_EM_CHECK_COMPATIBILITY = PREF_EM_CHECK_COMPATIBILITY_BASE + ".nightly";
 #else
 var PREF_EM_CHECK_COMPATIBILITY;
 #endif
 const TOOLKIT_ID                      = "toolkit@mozilla.org";
 const VALID_TYPES_REGEXP = /^[\w\-]+$/;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/AsyncShutdown.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository",
                                   "resource://gre/modules/addons/AddonRepository.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
                                   "resource://gre/modules/FileUtils.jsm");
 XPCOMUtils.defineLazyGetter(this, "CertUtils", function certUtilsLazyGetter() {
   let certUtils = {};
   Components.utils.import("resource://gre/modules/CertUtils.jsm", certUtils);
   return certUtils;
 });
 this.EXPORTED_SYMBOLS = [ "AddonManager", "AddonManagerPrivate" ];
 const CATEGORY_PROVIDER_MODULE = "addon-provider-module";
 // A list of providers to load by default
 const DEFAULT_PROVIDERS = [
   "resource://gre/modules/addons/XPIProvider.jsm",
   "resource://gre/modules/LightweightThemeManager.jsm"
 ];
 Cu.import("resource://gre/modules/Log.jsm");
 // Configure a logger at the parent 'addons' level to format
 // messages for all the modules under addons.*
 const PARENT_LOGGER_ID = "addons";
 let parentLogger = Log.repository.getLogger(PARENT_LOGGER_ID);
 parentLogger.level = Log.Level.Warn;
 let formatter = new Log.BasicFormatter();
 // Set parent logger (and its children) to append to
 // the Javascript section of the Browser Console
 parentLogger.addAppender(new Log.ConsoleAppender(formatter));
 // Set parent logger (and its children) to
 // also append to standard out
 parentLogger.addAppender(new Log.DumpAppender(formatter));
 // Create a new logger (child of 'addons' logger)
 // for use by the Addons Manager
 const LOGGER_ID = "addons.manager";
 let logger = Log.repository.getLogger(LOGGER_ID);
 // Provide the ability to enable/disable logging
 // messages at runtime.
 // If the "extensions.logging.enabled" preference is
 // missing or 'false', messages at the WARNING and higher
 // severity should be logged to the JS console and standard error.
 // If "extensions.logging.enabled" is set to 'true', messages
 // at DEBUG and higher should go to JS console and standard error.
 const PREF_LOGGING_ENABLED = "extensions.logging.enabled";
 const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";
 /**
  * Preference listener which listens for a change in the
  * "extensions.logging.enabled" preference and changes the logging level of the
  * parent 'addons' level logger accordingly.
  */
 var PrefObserver = {
     init: function PrefObserver_init() {
       Services.prefs.addObserver(PREF_LOGGING_ENABLED, this, false);
       Services.obs.addObserver(this, "xpcom-shutdown", false);
       this.observe(null, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, PREF_LOGGING_ENABLED);
     },
     observe: function PrefObserver_observe(aSubject, aTopic, aData) {
       if (aTopic == "xpcom-shutdown") {
         Services.prefs.removeObserver(PREF_LOGGING_ENABLED, this);
         Services.obs.removeObserver(this, "xpcom-shutdown");
       }
       else if (aTopic == NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) {
         let debugLogEnabled = false;
         try {
           debugLogEnabled = Services.prefs.getBoolPref(PREF_LOGGING_ENABLED);
         }
         catch (e) {
         }
         if (debugLogEnabled) {
           parentLogger.level = Log.Level.Debug;
         }
         else {
           parentLogger.level = Log.Level.Warn;
         }
       }
     }
 };
 PrefObserver.init();
 /**
  * Calls a callback method consuming any thrown exception. Any parameters after
  * the callback parameter will be passed to the callback.
  *
  * @param  aCallback
  *         The callback method to call
  */
 function safeCall(aCallback, ...aArgs) {
   try {
     aCallback.apply(null, aArgs);
   }
   catch (e) {
     logger.warn("Exception calling callback", e);
   }
 }
 /**
  * Calls a method on a provider if it exists and consumes any thrown exception.
  * Any parameters after the dflt parameter are passed to the provider's method.
  *
  * @param  aProvider
  *         The provider to call
  * @param  aMethod
  *         The method name to call
  * @param  aDefault
  *         A default return value if the provider does not implement the named
  *         method or throws an error.
  * @return the return value from the provider or dflt if the provider does not
  *         implement method or throws an error
  */
 function callProvider(aProvider, aMethod, aDefault, ...aArgs) {
   if (!(aMethod in aProvider))
     return aDefault;
   try {
     return aProvider[aMethod].apply(aProvider, aArgs);
   }
   catch (e) {
     logger.error("Exception calling provider " + aMethod, e);
     return aDefault;
   }
 }
 /**
  * Gets the currently selected locale for display.
  * @return  the selected locale or "en-US" if none is selected
  */
 function getLocale() {
   try {
     if (Services.prefs.getBoolPref(PREF_MATCH_OS_LOCALE))
       return Services.locale.getLocaleComponentForUserAgent();
   }
   catch (e) { }
   try {
     let locale = Services.prefs.getComplexValue(PREF_SELECTED_LOCALE,
                                                 Ci.nsIPrefLocalizedString);
     if (locale)
       return locale;
   }
   catch (e) { }
   try {
     return Services.prefs.getCharPref(PREF_SELECTED_LOCALE);
   }
   catch (e) { }
   return "en-US";
 }
 /**
  * A helper class to repeatedly call a listener with each object in an array
  * optionally checking whether the object has a method in it.
  *
  * @param  aObjects
  *         The array of objects to iterate through
  * @param  aMethod
  *         An optional method name, if not null any objects without this method
  *         will not be passed to the listener
  * @param  aListener
  *         A listener implementing nextObject and noMoreObjects methods. The
  *         former will be called with the AsyncObjectCaller as the first
  *         parameter and the object as the second. noMoreObjects will be passed
  *         just the AsyncObjectCaller
  */
 function AsyncObjectCaller(aObjects, aMethod, aListener) {
   this.objects = aObjects.slice(0);
   this.method = aMethod;
   this.listener = aListener;
   this.callNext();
 }
 AsyncObjectCaller.prototype = {
   objects: null,
   method: null,
   listener: null,
   /**
    * Passes the next object to the listener or calls noMoreObjects if there
    * are none left.
    */
   callNext: function AOC_callNext() {
     if (this.objects.length == 0) {
       this.listener.noMoreObjects(this);
       return;
     }
     let object = this.objects.shift();
     if (!this.method || this.method in object)
       this.listener.nextObject(this, object);
     else
       this.callNext();
   }
 };
 /**
  * This represents an author of an add-on (e.g. creator or developer)
  *
  * @param  aName
  *         The name of the author
  * @param  aURL
  *         The URL of the author's profile page
  */
 function AddonAuthor(aName, aURL) {
   this.name = aName;
   this.url = aURL;
 }
 AddonAuthor.prototype = {
   name: null,
   url: null,
   // Returns the author's name, defaulting to the empty string
   toString: function AddonAuthor_toString() {
     return this.name || "";
   }
 }
 /**
  * This represents an screenshot for an add-on
  *
  * @param  aURL
  *         The URL to the full version of the screenshot
  * @param  aWidth
  *         The width in pixels of the screenshot
  * @param  aHeight
  *         The height in pixels of the screenshot
  * @param  aThumbnailURL
  *         The URL to the thumbnail version of the screenshot
  * @param  aThumbnailWidth
  *         The width in pixels of the thumbnail version of the screenshot
  * @param  aThumbnailHeight
  *         The height in pixels of the thumbnail version of the screenshot
  * @param  aCaption
  *         The caption of the screenshot
  */
 function AddonScreenshot(aURL, aWidth, aHeight, aThumbnailURL,
                          aThumbnailWidth, aThumbnailHeight, aCaption) {
   this.url = aURL;
   if (aWidth) this.width = aWidth;
   if (aHeight) this.height = aHeight;
   if (aThumbnailURL) this.thumbnailURL = aThumbnailURL;
   if (aThumbnailWidth) this.thumbnailWidth = aThumbnailWidth;
   if (aThumbnailHeight) this.thumbnailHeight = aThumbnailHeight;
   if (aCaption) this.caption = aCaption;
 }
 AddonScreenshot.prototype = {
   url: null,
   width: null,
   height: null,
   thumbnailURL: null,
   thumbnailWidth: null,
   thumbnailHeight: null,
   caption: null,
   // Returns the screenshot URL, defaulting to the empty string
   toString: function AddonScreenshot_toString() {
     return this.url || "";
   }
 }
 /**
  * This represents a compatibility override for an addon.
  *
  * @param  aType
  *         Overrride type - "compatible" or "incompatible"
  * @param  aMinVersion
  *         Minimum version of the addon to match
  * @param  aMaxVersion
  *         Maximum version of the addon to match
  * @param  aAppID
  *         Application ID used to match appMinVersion and appMaxVersion
  * @param  aAppMinVersion
  *         Minimum version of the application to match
  * @param  aAppMaxVersion
  *         Maximum version of the application to match
  */
 function AddonCompatibilityOverride(aType, aMinVersion, aMaxVersion, aAppID,
                                     aAppMinVersion, aAppMaxVersion) {
   this.type = aType;
   this.minVersion = aMinVersion;
   this.maxVersion = aMaxVersion;
   this.appID = aAppID;
   this.appMinVersion = aAppMinVersion;
   this.appMaxVersion = aAppMaxVersion;
 }
 AddonCompatibilityOverride.prototype = {
   /**
    * Type of override - "incompatible" or "compatible".
    * Only "incompatible" is supported for now.
    */
   type: null,
   /**
    * Min version of the addon to match.
    */
   minVersion: null,
   /**
    * Max version of the addon to match.
    */
   maxVersion: null,
   /**
    * Application ID to match.
    */
   appID: null,
   /**
    * Min version of the application to match.
    */
   appMinVersion: null,
   /**
    * Max version of the application to match.
    */
   appMaxVersion: null
 };
 /**
  * A type of add-on, used by the UI to determine how to display different types
  * of add-ons.
  *
  * @param  aID
  *         The add-on type ID
  * @param  aLocaleURI
  *         The URI of a localized properties file to get the displayable name
  *         for the type from
  * @param  aLocaleKey
  *         The key for the string in the properties file or the actual display
  *         name if aLocaleURI is null. Include %ID% to include the type ID in
  *         the key
  * @param  aViewType
  *         The optional type of view to use in the UI
  * @param  aUIPriority
  *         The priority is used by the UI to list the types in order. Lower
  *         values push the type higher in the list.
  * @param  aFlags
  *         An option set of flags that customize the display of the add-on in
  *         the UI.
  */
 function AddonType(aID, aLocaleURI, aLocaleKey, aViewType, aUIPriority, aFlags) {
   if (!aID)
     throw Components.Exception("An AddonType must have an ID", Cr.NS_ERROR_INVALID_ARG);
   if (aViewType && aUIPriority === undefined)
     throw Components.Exception("An AddonType with a defined view must have a set UI priority",
                                Cr.NS_ERROR_INVALID_ARG);
   if (!aLocaleKey)
     throw Components.Exception("An AddonType must have a displayable name",
                                Cr.NS_ERROR_INVALID_ARG);
   this.id = aID;
   this.uiPriority = aUIPriority;
   this.viewType = aViewType;
   this.flags = aFlags;
   if (aLocaleURI) {
     this.__defineGetter__("name", function nameGetter() {
       delete this.name;
       let bundle = Services.strings.createBundle(aLocaleURI);
       this.name = bundle.GetStringFromName(aLocaleKey.replace("%ID%", aID));
       return this.name;
     });
   }
   else {
     this.name = aLocaleKey;
   }
 }
 var gStarted = false;
 var gStartupComplete = false;
 var gCheckCompatibility = true;
 var gStrictCompatibility = true;
 var gCheckUpdateSecurityDefault = true;
 var gCheckUpdateSecurity = gCheckUpdateSecurityDefault;
 var gUpdateEnabled = true;
 var gAutoUpdateDefault = true;
 var gHotfixID = null;
 /**
  * This is the real manager, kept here rather than in AddonManager to keep its
  * contents hidden from API users.
  */
 var AddonManagerInternal = {
   managerListeners: [],
   installListeners: [],
   addonListeners: [],
   typeListeners: [],
   providers: [],
   types: {},
   startupChanges: {},
   // Store telemetry details per addon provider
   telemetryDetails: {},
   // A read-only wrapper around the types dictionary
   typesProxy: Proxy.create({
     getOwnPropertyDescriptor: function typesProxy_getOwnPropertyDescriptor(aName) {
       if (!(aName in AddonManagerInternal.types))
         return undefined;
       return {
         value: AddonManagerInternal.types[aName].type,
         writable: false,
         configurable: false,
         enumerable: true
       }
     },
     getPropertyDescriptor: function typesProxy_getPropertyDescriptor(aName) {
       return this.getOwnPropertyDescriptor(aName);
     },
     getOwnPropertyNames: function typesProxy_getOwnPropertyNames() {
       return Object.keys(AddonManagerInternal.types);
     },
     getPropertyNames: function typesProxy_getPropertyNames() {
       return this.getOwnPropertyNames();
     },
     delete: function typesProxy_delete(aName) {
       // Not allowed to delete properties
       return false;
     },
     defineProperty: function typesProxy_defineProperty(aName, aProperty) {
       // Ignore attempts to define properties
     },
     fix: function typesProxy_fix(){
       return undefined;
     },
     // Despite MDC's claims to the contrary, it is required that this trap
     // be defined
     enumerate: function typesProxy_enumerate() {
       // All properties are enumerable
       return this.getPropertyNames();
     }
   }),
   recordTimestamp: function AMI_recordTimestamp(name, value) {
     this.TelemetryTimestamps.add(name, value);
   },
   validateBlocklist: function AMI_validateBlocklist() {
     let appBlocklist = FileUtils.getFile(KEY_APPDIR, [FILE_BLOCKLIST]);
     // If there is no application shipped blocklist then there is nothing to do
     if (!appBlocklist.exists())
       return;
     let profileBlocklist = FileUtils.getFile(KEY_PROFILEDIR, [FILE_BLOCKLIST]);
     // If there is no blocklist in the profile then copy the application shipped
     // one there
     if (!profileBlocklist.exists()) {
       try {
         appBlocklist.copyTo(profileBlocklist.parent, FILE_BLOCKLIST);
       }
       catch (e) {
         logger.warn("Failed to copy the application shipped blocklist to the profile", e);
       }
       return;
     }
     let fileStream = Cc["@mozilla.org/network/file-input-stream;1"].
                      createInstance(Ci.nsIFileInputStream);
     try {
       let cstream = Cc["@mozilla.org/intl/converter-input-stream;1"].
                     createInstance(Ci.nsIConverterInputStream);
       fileStream.init(appBlocklist, FileUtils.MODE_RDONLY, FileUtils.PERMS_FILE, 0);
       cstream.init(fileStream, "UTF-8", 0, 0);
       let data = "";
       let str = {};
       let read = 0;
       do {
         read = cstream.readString(0xffffffff, str);
         data += str.value;
       } while (read != 0);
       let parser = Cc["@mozilla.org/xmlextras/domparser;1"].
                    createInstance(Ci.nsIDOMParser);
       var doc = parser.parseFromString(data, "text/xml");
     }
     catch (e) {
       logger.warn("Application shipped blocklist could not be loaded", e);
       return;
     }
     finally {
       try {
         fileStream.close();
       }
       catch (e) {
         logger.warn("Unable to close blocklist file stream", e);
       }
     }
     // If the namespace is incorrect then ignore the application shipped
     // blocklist
     if (doc.documentElement.namespaceURI != XMLURI_BLOCKLIST) {
       logger.warn("Application shipped blocklist has an unexpected namespace (" +
                   doc.documentElement.namespaceURI + ")");
       return;
     }
     // If there is no lastupdate information then ignore the application shipped
     // blocklist
     if (!doc.documentElement.hasAttribute("lastupdate"))
       return;
     // If the application shipped blocklist is older than the profile blocklist
     // then do nothing
     if (doc.documentElement.getAttribute("lastupdate") <=
         profileBlocklist.lastModifiedTime)
       return;
     // Otherwise copy the application shipped blocklist to the profile
     try {
       appBlocklist.copyTo(profileBlocklist.parent, FILE_BLOCKLIST);
     }
     catch (e) {
       logger.warn("Failed to copy the application shipped blocklist to the profile", e);
     }
   },
   /**
    * Initializes the AddonManager, loading any known providers and initializing
    * them.
    */
   startup: function AMI_startup() {
     try {
       if (gStarted)
         return;
       this.recordTimestamp("AMI_startup_begin");
       // clear this for xpcshell test restarts
       for (let provider in this.telemetryDetails)
         delete this.telemetryDetails[provider];
       let appChanged = undefined;
       let oldAppVersion = null;
       try {
         oldAppVersion = Services.prefs.getCharPref(PREF_EM_LAST_APP_VERSION);
         appChanged = Services.appinfo.version != oldAppVersion;
       }
       catch (e) { }
       let oldPlatformVersion = null;
       try {
         oldPlatformVersion = Services.prefs.getCharPref(PREF_EM_LAST_PLATFORM_VERSION);
       }
       catch (e) { }
       if (appChanged !== false) {
         logger.debug("Application has been upgraded");
         Services.prefs.setCharPref(PREF_EM_LAST_APP_VERSION,
                                    Services.appinfo.version);
         Services.prefs.setCharPref(PREF_EM_LAST_PLATFORM_VERSION,
                                    Services.appinfo.platformVersion);
         Services.prefs.setIntPref(PREF_BLOCKLIST_PINGCOUNTVERSION,
                                   (appChanged === undefined ? 0 : -1));
         this.validateBlocklist();
       }
 #ifndef MOZ_COMPATIBILITY_NIGHTLY
       PREF_EM_CHECK_COMPATIBILITY = PREF_EM_CHECK_COMPATIBILITY_BASE + "." +
                                     Services.appinfo.version.replace(BRANCH_REGEXP, "$1");
 #endif
       try {
         gCheckCompatibility = Services.prefs.getBoolPref(PREF_EM_CHECK_COMPATIBILITY);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_CHECK_COMPATIBILITY, this, false);
       try {
         gStrictCompatibility = Services.prefs.getBoolPref(PREF_EM_STRICT_COMPATIBILITY);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_STRICT_COMPATIBILITY, this, false);
       try {
         let defaultBranch = Services.prefs.getDefaultBranch("");
         gCheckUpdateSecurityDefault = defaultBranch.getBoolPref(PREF_EM_CHECK_UPDATE_SECURITY);
       } catch(e) {}
       try {
         gCheckUpdateSecurity = Services.prefs.getBoolPref(PREF_EM_CHECK_UPDATE_SECURITY);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_CHECK_UPDATE_SECURITY, this, false);
       try {
         gUpdateEnabled = Services.prefs.getBoolPref(PREF_EM_UPDATE_ENABLED);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_UPDATE_ENABLED, this, false);
       try {
         gAutoUpdateDefault = Services.prefs.getBoolPref(PREF_EM_AUTOUPDATE_DEFAULT);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_AUTOUPDATE_DEFAULT, this, false);
       try {
         gHotfixID = Services.prefs.getCharPref(PREF_EM_HOTFIX_ID);
       } catch (e) {}
       Services.prefs.addObserver(PREF_EM_HOTFIX_ID, this, false);
       let defaultProvidersEnabled = true;
       try {
         defaultProvidersEnabled = Services.prefs.getBoolPref(PREF_DEFAULT_PROVIDERS_ENABLED);
       } catch (e) {}
       AddonManagerPrivate.recordSimpleMeasure("default_providers", defaultProvidersEnabled);
       // Ensure all default providers have had a chance to register themselves
       if (defaultProvidersEnabled) {
         for (let url of DEFAULT_PROVIDERS) {
           try {
             let scope = {};
             Components.utils.import(url, scope);
             // Sanity check - make sure the provider exports a symbol that
             // has a 'startup' method
             let syms = Object.keys(scope);
             if ((syms.length < 1) ||
                 (typeof scope[syms[0]].startup != "function")) {
               logger.warn("Provider " + url + " has no startup()");
               AddonManagerPrivate.recordException("AMI", "provider " + url, "no startup()");
             }
             logger.debug("Loaded provider scope for " + url + ": " + Object.keys(scope).toSource());
           }
           catch (e) {
             AddonManagerPrivate.recordException("AMI", "provider " + url + " load failed", e);
             logger.error("Exception loading default provider \"" + url + "\"", e);
           }
         };
       }
       // Load any providers registered in the category manager
       let catman = Cc["@mozilla.org/categorymanager;1"].
                    getService(Ci.nsICategoryManager);
       let entries = catman.enumerateCategory(CATEGORY_PROVIDER_MODULE);
       while (entries.hasMoreElements()) {
         let entry = entries.getNext().QueryInterface(Ci.nsISupportsCString).data;
         let url = catman.getCategoryEntry(CATEGORY_PROVIDER_MODULE, entry);
         try {
           Components.utils.import(url, {});
         }
         catch (e) {
           AddonManagerPrivate.recordException("AMI", "provider " + url + " load failed", e);
           logger.error("Exception loading provider " + entry + " from category \"" +
                 url + "\"", e);
         }
       }
       // Register our shutdown handler with the AsyncShutdown manager
       AsyncShutdown.profileBeforeChange.addBlocker("AddonManager: shutting down providers",
                                                    this.shutdown.bind(this));
       // Once we start calling providers we must allow all normal methods to work.
       gStarted = true;
       this.callProviders("startup", appChanged, oldAppVersion,
                          oldPlatformVersion);
       // If this is a new profile just pretend that there were no changes
       if (appChanged === undefined) {
         for (let type in this.startupChanges)
           delete this.startupChanges[type];
       }
       gStartupComplete = true;
       this.recordTimestamp("AMI_startup_end");
     }
     catch (e) {
       logger.error("startup failed", e);
       AddonManagerPrivate.recordException("AMI", "startup failed", e);
     }
   },
   /**
    * Registers a new AddonProvider.
    *
    * @param  aProvider
    *         The provider to register
    * @param  aTypes
    *         An optional array of add-on types
    */
   registerProvider: function AMI_registerProvider(aProvider, aTypes) {
     if (!aProvider || typeof aProvider != "object")
       throw Components.Exception("aProvider must be specified",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aTypes && !Array.isArray(aTypes))
       throw Components.Exception("aTypes must be an array or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     this.providers.push(aProvider);
     if (aTypes) {
       aTypes.forEach(function(aType) {
         if (!(aType.id in this.types)) {
           if (!VALID_TYPES_REGEXP.test(aType.id)) {
             logger.warn("Ignoring invalid type " + aType.id);
             return;
           }
           this.types[aType.id] = {
             type: aType,
             providers: [aProvider]
           };
           let typeListeners = this.typeListeners.slice(0);
           for (let listener of typeListeners) {
             safeCall(function listenerSafeCall() {
               listener.onTypeAdded(aType);
             });
           }
         }
         else {
           this.types[aType.id].providers.push(aProvider);
         }
       }, this);
     }
     // If we're registering after startup call this provider's startup.
     if (gStarted)
       callProvider(aProvider, "startup");
   },
   /**
    * Unregisters an AddonProvider.
    *
    * @param  aProvider
    *         The provider to unregister
    */
   unregisterProvider: function AMI_unregisterProvider(aProvider) {
     if (!aProvider || typeof aProvider != "object")
       throw Components.Exception("aProvider must be specified",
                                  Cr.NS_ERROR_INVALID_ARG);
     let pos = 0;
     while (pos < this.providers.length) {
       if (this.providers[pos] == aProvider)
         this.providers.splice(pos, 1);
       else
         pos++;
     }
     for (let type in this.types) {
       this.types[type].providers = this.types[type].providers.filter(function filterProvider(p) p != aProvider);
       if (this.types[type].providers.length == 0) {
         let oldType = this.types[type].type;
         delete this.types[type];
         let typeListeners = this.typeListeners.slice(0);
         for (let listener of typeListeners) {
           safeCall(function listenerSafeCall() {
             listener.onTypeRemoved(oldType);
           });
         }
       }
     }
     // If we're unregistering after startup call this provider's shutdown.
     if (gStarted)
       callProvider(aProvider, "shutdown");
   },
   /**
    * Calls a method on all registered providers if it exists and consumes any
    * thrown exception. Return values are ignored. Any parameters after the
    * method parameter are passed to the provider's method.
    *
    * @param  aMethod
    *         The method name to call
    * @see    callProvider
    */
   callProviders: function AMI_callProviders(aMethod, ...aArgs) {
     if (!aMethod || typeof aMethod != "string")
       throw Components.Exception("aMethod must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       try {
         if (aMethod in provider)
           provider[aMethod].apply(provider, aArgs);
       }
       catch (e) {
         AddonManagerPrivate.recordException("AMI", "provider " + aMethod, e);
         logger.error("Exception calling provider " + aMethod, e);
       }
     }
   },
   /**
    * Calls a method on all registered providers, if the provider implements
    * the method. The called method is expected to return a promise, and
    * callProvidersAsync returns a promise that resolves when every provider
    * method has either resolved or rejected. Rejection reasons are logged
    * but otherwise ignored. Return values are ignored. Any parameters after the
    * method parameter are passed to the provider's method.
    *
    * @param  aMethod
    *         The method name to call
    * @see    callProvider
    */
   callProvidersAsync: function AMI_callProviders(aMethod, ...aArgs) {
     if (!aMethod || typeof aMethod != "string")
       throw Components.Exception("aMethod must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     let allProviders = [];
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       try {
         if (aMethod in provider) {
           // Resolve a new promise with the result of the method, to handle both
           // methods that return values (or nothing) and methods that return promises.
           let providerResult = provider[aMethod].apply(provider, aArgs);
           let nextPromise = Promise.resolve(providerResult);
           // Log and swallow the errors from methods that do return promises.
           nextPromise = nextPromise.then(
               null,
               e => logger.error("Exception calling provider " + aMethod, e));
           allProviders.push(nextPromise);
         }
       }
       catch (e) {
         logger.error("Exception calling provider " + aMethod, e);
       }
     }
     // Because we use promise.then to catch and log all errors above, Promise.all()
     // will never exit early because of a rejection.
     return Promise.all(allProviders);
   },
   /**
    * Shuts down the addon manager and all registered providers, this must clean
    * up everything in order for automated tests to fake restarts.
    * @return Promise{null} that resolves when all providers and dependent modules
    *                       have finished shutting down
    */
   shutdown: function AMI_shutdown() {
     logger.debug("shutdown");
     // Clean up listeners
     Services.prefs.removeObserver(PREF_EM_CHECK_COMPATIBILITY, this);
     Services.prefs.removeObserver(PREF_EM_STRICT_COMPATIBILITY, this);
     Services.prefs.removeObserver(PREF_EM_CHECK_UPDATE_SECURITY, this);
     Services.prefs.removeObserver(PREF_EM_UPDATE_ENABLED, this);
     Services.prefs.removeObserver(PREF_EM_AUTOUPDATE_DEFAULT, this);
     Services.prefs.removeObserver(PREF_EM_HOTFIX_ID, this);
     // Only shut down providers if they've been started. Shut down
     // AddonRepository after providers (if any).
     let shuttingDown = null;
     if (gStarted) {
       shuttingDown = this.callProvidersAsync("shutdown")
         .then(null,
               err => logger.error("Failure during async provider shutdown", err))
         .then(() => AddonRepository.shutdown());
     }
     else {
       shuttingDown = AddonRepository.shutdown();
     }
       shuttingDown.then(val => logger.debug("Async provider shutdown done"),
                         err => logger.error("Failure during AddonRepository shutdown", err))
       .then(() => {
         this.managerListeners.splice(0, this.managerListeners.length);
         this.installListeners.splice(0, this.installListeners.length);
         this.addonListeners.splice(0, this.addonListeners.length);
         this.typeListeners.splice(0, this.typeListeners.length);
         for (let type in this.startupChanges)
           delete this.startupChanges[type];
         gStarted = false;
         gStartupComplete = false;
       });
     return shuttingDown;
   },
   /**
    * Notified when a preference we're interested in has changed.
    *
    * @see nsIObserver
    */
   observe: function AMI_observe(aSubject, aTopic, aData) {
     switch (aData) {
       case PREF_EM_CHECK_COMPATIBILITY: {
         let oldValue = gCheckCompatibility;
         try {
           gCheckCompatibility = Services.prefs.getBoolPref(PREF_EM_CHECK_COMPATIBILITY);
         } catch(e) {
           gCheckCompatibility = true;
         }
         this.callManagerListeners("onCompatibilityModeChanged");
         if (gCheckCompatibility != oldValue)
           this.updateAddonAppDisabledStates();
         break;
       }
       case PREF_EM_STRICT_COMPATIBILITY: {
         let oldValue = gStrictCompatibility;
         try {
           gStrictCompatibility = Services.prefs.getBoolPref(PREF_EM_STRICT_COMPATIBILITY);
         } catch(e) {
           gStrictCompatibility = true;
         }
         this.callManagerListeners("onCompatibilityModeChanged");
         if (gStrictCompatibility != oldValue)
           this.updateAddonAppDisabledStates();
         break;
       }
       case PREF_EM_CHECK_UPDATE_SECURITY: {
         let oldValue = gCheckUpdateSecurity;
         try {
           gCheckUpdateSecurity = Services.prefs.getBoolPref(PREF_EM_CHECK_UPDATE_SECURITY);
         } catch(e) {
           gCheckUpdateSecurity = true;
         }
         this.callManagerListeners("onCheckUpdateSecurityChanged");
         if (gCheckUpdateSecurity != oldValue)
           this.updateAddonAppDisabledStates();
         break;
       }
       case PREF_EM_UPDATE_ENABLED: {
         let oldValue = gUpdateEnabled;
         try {
           gUpdateEnabled = Services.prefs.getBoolPref(PREF_EM_UPDATE_ENABLED);
         } catch(e) {
           gUpdateEnabled = true;
         }
         this.callManagerListeners("onUpdateModeChanged");
         break;
       }
       case PREF_EM_AUTOUPDATE_DEFAULT: {
         let oldValue = gAutoUpdateDefault;
         try {
           gAutoUpdateDefault = Services.prefs.getBoolPref(PREF_EM_AUTOUPDATE_DEFAULT);
         } catch(e) {
           gAutoUpdateDefault = true;
         }
         this.callManagerListeners("onUpdateModeChanged");
         break;
       }
       case PREF_EM_HOTFIX_ID: {
         try {
           gHotfixID = Services.prefs.getCharPref(PREF_EM_HOTFIX_ID);
         } catch(e) {
           gHotfixID = null;
         }
         break;
       }
     }
   },
   /**
    * Replaces %...% strings in an addon url (update and updateInfo) with
    * appropriate values.
    *
    * @param  aAddon
    *         The Addon representing the add-on
    * @param  aUri
    *         The string representation of the URI to escape
    * @param  aAppVersion
    *         The optional application version to use for %APP_VERSION%
    * @return The appropriately escaped URI.
    */
   escapeAddonURI: function AMI_escapeAddonURI(aAddon, aUri, aAppVersion)
   {
     if (!aAddon || typeof aAddon != "object")
       throw Components.Exception("aAddon must be an Addon object",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!aUri || typeof aUri != "string")
       throw Components.Exception("aUri must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aAppVersion && typeof aAppVersion != "string")
       throw Components.Exception("aAppVersion must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     var addonStatus = aAddon.userDisabled || aAddon.softDisabled ? "userDisabled"
                                                                  : "userEnabled";
     if (!aAddon.isCompatible)
       addonStatus += ",incompatible";
     if (aAddon.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED)
       addonStatus += ",blocklisted";
     if (aAddon.blocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED)
       addonStatus += ",softblocked";
     try {
       var xpcomABI = Services.appinfo.XPCOMABI;
     } catch (ex) {
       xpcomABI = UNKNOWN_XPCOM_ABI;
     }
     let uri = aUri.replace(/%ITEM_ID%/g, aAddon.id);
     uri = uri.replace(/%ITEM_VERSION%/g, aAddon.version);
     uri = uri.replace(/%ITEM_STATUS%/g, addonStatus);
     uri = uri.replace(/%APP_ID%/g, Services.appinfo.ID);
     uri = uri.replace(/%APP_VERSION%/g, aAppVersion ? aAppVersion :
                                                       Services.appinfo.version);
     uri = uri.replace(/%REQ_VERSION%/g, UPDATE_REQUEST_VERSION);
     uri = uri.replace(/%APP_OS%/g, Services.appinfo.OS);
     uri = uri.replace(/%APP_ABI%/g, xpcomABI);
     uri = uri.replace(/%APP_LOCALE%/g, getLocale());
     uri = uri.replace(/%CURRENT_APP_VERSION%/g, Services.appinfo.version);
     // Replace custom parameters (names of custom parameters must have at
     // least 3 characters to prevent lookups for something like %D0%C8)
     var catMan = null;
     uri = uri.replace(/%(\w{3,})%/g, function parameterReplace(aMatch, aParam) {
       if (!catMan) {
         catMan = Cc["@mozilla.org/categorymanager;1"].
                  getService(Ci.nsICategoryManager);
       }
       try {
         var contractID = catMan.getCategoryEntry(CATEGORY_UPDATE_PARAMS, aParam);
         var paramHandler = Cc[contractID].getService(Ci.nsIPropertyBag2);
         return paramHandler.getPropertyAsAString(aParam);
       }
       catch(e) {
         return aMatch;
       }
     });
     // escape() does not properly encode + symbols in any embedded FVF strings.
     return uri.replace(/\+/g, "%2B");
   },
   /**
    * Performs a background update check by starting an update for all add-ons
    * that can be updated.
    */
   backgroundUpdateCheck: function AMI_backgroundUpdateCheck() {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     let hotfixID = this.hotfixID;
     let checkHotfix = hotfixID &&
                       Services.prefs.getBoolPref(PREF_APP_UPDATE_ENABLED) &&
                       Services.prefs.getBoolPref(PREF_APP_UPDATE_AUTO);
     if (!this.updateEnabled && !checkHotfix)
       return;
     Services.obs.notifyObservers(null, "addons-background-update-start", null);
     // Start this from one to ensure the whole of this function completes before
     // we can send the complete notification. Some parts can in some cases
     // complete synchronously before later parts have a chance to increment
     // pendingUpdates.
     let pendingUpdates = 1;
     function notifyComplete() {
       if (--pendingUpdates == 0) {
         Services.obs.notifyObservers(null,
                                      "addons-background-update-complete",
                                      null);
       }
     }
     if (this.updateEnabled) {
       let scope = {};
       Components.utils.import("resource://gre/modules/LightweightThemeManager.jsm", scope);
       scope.LightweightThemeManager.updateCurrentTheme();
       pendingUpdates++;
       this.getAllAddons(function getAddonsCallback(aAddons) {
         // If there is a known hotfix then exclude it from the list of add-ons to update.
         var ids = [a.id for each (a in aAddons) if (a.id != hotfixID)];
         // Repopulate repository cache first, to ensure compatibility overrides
         // are up to date before checking for addon updates.
         AddonRepository.backgroundUpdateCheck(
                      ids, function BUC_backgroundUpdateCheckCallback() {
           pendingUpdates += aAddons.length;
           aAddons.forEach(function BUC_forEachCallback(aAddon) {
             if (aAddon.id == hotfixID) {
               notifyComplete();
               return;
             }
             // Check all add-ons for updates so that any compatibility updates will
             // be applied
             aAddon.findUpdates({
               onUpdateAvailable: function BUC_onUpdateAvailable(aAddon, aInstall) {
                 // Start installing updates when the add-on can be updated and
                 // background updates should be applied.
                 if (aAddon.permissions & AddonManager.PERM_CAN_UPGRADE &&
                     AddonManager.shouldAutoUpdate(aAddon)) {
                   aInstall.install();
                 }
               },
               onUpdateFinished: notifyComplete
             }, AddonManager.UPDATE_WHEN_PERIODIC_UPDATE);
           });
           notifyComplete();
         });
       });
     }
     if (checkHotfix) {
       var hotfixVersion = "";
       try {
         hotfixVersion = Services.prefs.getCharPref(PREF_EM_HOTFIX_LASTVERSION);
       }
       catch (e) { }
       let url = null;
       if (Services.prefs.getPrefType(PREF_EM_HOTFIX_URL) == Ci.nsIPrefBranch.PREF_STRING)
         url = Services.prefs.getCharPref(PREF_EM_HOTFIX_URL);
       else
         url = Services.prefs.getCharPref(PREF_EM_UPDATE_BACKGROUND_URL);
       // Build the URI from a fake add-on data.
       url = AddonManager.escapeAddonURI({
         id: hotfixID,
         version: hotfixVersion,
         userDisabled: false,
         appDisabled: false
       }, url);
       pendingUpdates++;
       Components.utils.import("resource://gre/modules/addons/AddonUpdateChecker.jsm");
       AddonUpdateChecker.checkForUpdates(hotfixID, null, url, {
         onUpdateCheckComplete: function BUC_onUpdateCheckComplete(aUpdates) {
           let update = AddonUpdateChecker.getNewestCompatibleUpdate(aUpdates);
           if (!update) {
             notifyComplete();
             return;
           }
           // If the available version isn't newer than the last installed
           // version then ignore it.
           if (Services.vc.compare(hotfixVersion, update.version) >= 0) {
             notifyComplete();
             return;
           }
           logger.debug("Downloading hotfix version " + update.version);
           AddonManager.getInstallForURL(update.updateURL,
                                        function BUC_getInstallForURL(aInstall) {
             aInstall.addListener({
               onDownloadEnded: function BUC_onDownloadEnded(aInstall) {
                 try {
                   if (!Services.prefs.getBoolPref(PREF_EM_CERT_CHECKATTRIBUTES))
                     return;
                 }
                 catch (e) {
                   // By default don't do certificate checks.
                   return;
                 }
                 try {
                   CertUtils.validateCert(aInstall.certificate,
                                          CertUtils.readCertPrefs(PREF_EM_HOTFIX_CERTS));
                 }
                 catch (e) {
                   logger.warn("The hotfix add-on was not signed by the expected " +
                        "certificate and so will not be installed.");
                   aInstall.cancel();
                 }
               },
               onInstallEnded: function BUC_onInstallEnded(aInstall) {
                 // Remember the last successfully installed version.
                 Services.prefs.setCharPref(PREF_EM_HOTFIX_LASTVERSION,
                                            aInstall.version);
               },
               onInstallCancelled: function BUC_onInstallCancelled(aInstall) {
                 // Revert to the previous version if the installation was
                 // cancelled.
                 Services.prefs.setCharPref(PREF_EM_HOTFIX_LASTVERSION,
                                            hotfixVersion);
               }
             });
             aInstall.install();
             notifyComplete();
           }, "application/x-xpinstall", update.updateHash, null,
              null, update.version);
         },
         onUpdateCheckError: notifyComplete
       });
     }
     notifyComplete();
   },
   /**
    * Adds a add-on to the list of detected changes for this startup. If
    * addStartupChange is called multiple times for the same add-on in the same
    * startup then only the most recent change will be remembered.
    *
    * @param  aType
    *         The type of change as a string. Providers can define their own
    *         types of changes or use the existing defined STARTUP_CHANGE_*
    *         constants
    * @param  aID
    *         The ID of the add-on
    */
   addStartupChange: function AMI_addStartupChange(aType, aID) {
     if (!aType || typeof aType != "string")
       throw Components.Exception("aType must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!aID || typeof aID != "string")
       throw Components.Exception("aID must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (gStartupComplete)
       return;
     // Ensure that an ID is only listed in one type of change
     for (let type in this.startupChanges)
       this.removeStartupChange(type, aID);
     if (!(aType in this.startupChanges))
       this.startupChanges[aType] = [];
     this.startupChanges[aType].push(aID);
   },
   /**
    * Removes a startup change for an add-on.
    *
    * @param  aType
    *         The type of change
    * @param  aID
    *         The ID of the add-on
    */
   removeStartupChange: function AMI_removeStartupChange(aType, aID) {
     if (!aType || typeof aType != "string")
       throw Components.Exception("aType must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!aID || typeof aID != "string")
       throw Components.Exception("aID must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (gStartupComplete)
       return;
     if (!(aType in this.startupChanges))
       return;
     this.startupChanges[aType] = this.startupChanges[aType].filter(
                                  function filterItem(aItem) aItem != aID);
   },
   /**
    * Calls all registered AddonManagerListeners with an event. Any parameters
    * after the method parameter are passed to the listener.
    *
    * @param  aMethod
    *         The method on the listeners to call
    */
   callManagerListeners: function AMI_callManagerListeners(aMethod, ...aArgs) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMethod || typeof aMethod != "string")
       throw Components.Exception("aMethod must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     let managerListeners = this.managerListeners.slice(0);
     for (let listener of managerListeners) {
       try {
         if (aMethod in listener)
           listener[aMethod].apply(listener, aArgs);
       }
       catch (e) {
         logger.warn("AddonManagerListener threw exception when calling " + aMethod, e);
       }
     }
   },
   /**
    * Calls all registered InstallListeners with an event. Any parameters after
    * the extraListeners parameter are passed to the listener.
    *
    * @param  aMethod
    *         The method on the listeners to call
    * @param  aExtraListeners
    *         An optional array of extra InstallListeners to also call
    * @return false if any of the listeners returned false, true otherwise
    */
   callInstallListeners: function AMI_callInstallListeners(aMethod,
                                  aExtraListeners, ...aArgs) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMethod || typeof aMethod != "string")
       throw Components.Exception("aMethod must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aExtraListeners && !Array.isArray(aExtraListeners))
       throw Components.Exception("aExtraListeners must be an array or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     let result = true;
     let listeners;
     if (aExtraListeners)
       listeners = aExtraListeners.concat(this.installListeners);
     else
       listeners = this.installListeners.slice(0);
     for (let listener of listeners) {
       try {
         if (aMethod in listener) {
           if (listener[aMethod].apply(listener, aArgs) === false)
             result = false;
         }
       }
       catch (e) {
         logger.warn("InstallListener threw exception when calling " + aMethod, e);
       }
     }
     return result;
   },
   /**
    * Calls all registered AddonListeners with an event. Any parameters after
    * the method parameter are passed to the listener.
    *
    * @param  aMethod
    *         The method on the listeners to call
    */
   callAddonListeners: function AMI_callAddonListeners(aMethod, ...aArgs) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMethod || typeof aMethod != "string")
       throw Components.Exception("aMethod must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     let addonListeners = this.addonListeners.slice(0);
     for (let listener of addonListeners) {
       try {
         if (aMethod in listener)
           listener[aMethod].apply(listener, aArgs);
       }
       catch (e) {
         logger.warn("AddonListener threw exception when calling " + aMethod, e);
       }
     }
   },
   /**
    * Notifies all providers that an add-on has been enabled when that type of
    * add-on only supports a single add-on being enabled at a time. This allows
    * the providers to disable theirs if necessary.
    *
    * @param  aID
    *         The ID of the enabled add-on
    * @param  aType
    *         The type of the enabled add-on
    * @param  aPendingRestart
    *         A boolean indicating if the change will only take place the next
    *         time the application is restarted
    */
   notifyAddonChanged: function AMI_notifyAddonChanged(aID, aType, aPendingRestart) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (aID && typeof aID != "string")
       throw Components.Exception("aID must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!aType || typeof aType != "string")
       throw Components.Exception("aType must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     this.callProviders("addonChanged", aID, aType, aPendingRestart);
   },
   /**
    * Notifies all providers they need to update the appDisabled property for
    * their add-ons in response to an application change such as a blocklist
    * update.
    */
   updateAddonAppDisabledStates: function AMI_updateAddonAppDisabledStates() {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     this.callProviders("updateAddonAppDisabledStates");
   },
   /**
    * Notifies all providers that the repository has updated its data for
    * installed add-ons.
    *
    * @param  aCallback
    *         Function to call when operation is complete.
    */
   updateAddonRepositoryData: function AMI_updateAddonRepositoryData(aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     new AsyncObjectCaller(this.providers, "updateAddonRepositoryData", {
       nextObject: function updateAddonRepositoryData_nextObject(aCaller, aProvider) {
         callProvider(aProvider,
                      "updateAddonRepositoryData",
                      null,
                      aCaller.callNext.bind(aCaller));
       },
       noMoreObjects: function updateAddonRepositoryData_noMoreObjects(aCaller) {
         safeCall(aCallback);
         // only tests should care about this
         Services.obs.notifyObservers(null, "TEST:addon-repository-data-updated", null);
       }
     });
   },
   /**
    * Asynchronously gets an AddonInstall for a URL.
    *
    * @param  aUrl
    *         The string represenation of the URL the add-on is located at
    * @param  aCallback
    *         A callback to pass the AddonInstall to
    * @param  aMimetype
    *         The mimetype of the add-on
    * @param  aHash
    *         An optional hash of the add-on
    * @param  aName
    *         An optional placeholder name while the add-on is being downloaded
    * @param  aIcons
    *         Optional placeholder icons while the add-on is being downloaded
    * @param  aVersion
    *         An optional placeholder version while the add-on is being downloaded
    * @param  aLoadGroup
    *         An optional nsILoadGroup to associate any network requests with
    * @throws if the aUrl, aCallback or aMimetype arguments are not specified
    */
   getInstallForURL: function AMI_getInstallForURL(aUrl, aCallback, aMimetype,
                                                   aHash, aName, aIcons,
                                                   aVersion, aLoadGroup) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aUrl || typeof aUrl != "string")
       throw Components.Exception("aURL must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!aMimetype || typeof aMimetype != "string")
       throw Components.Exception("aMimetype must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aHash && typeof aHash != "string")
       throw Components.Exception("aHash must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aName && typeof aName != "string")
       throw Components.Exception("aName must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aIcons) {
       if (typeof aIcons == "string")
         aIcons = { "32": aIcons };
       else if (typeof aIcons != "object")
         throw Components.Exception("aIcons must be a string, an object or null",
                                    Cr.NS_ERROR_INVALID_ARG);
     } else {
       aIcons = {};
     }
     if (aVersion && typeof aVersion != "string")
       throw Components.Exception("aVersion must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aLoadGroup && (!(aLoadGroup instanceof Ci.nsILoadGroup)))
       throw Components.Exception("aLoadGroup must be a nsILoadGroup or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       if (callProvider(provider, "supportsMimetype", false, aMimetype)) {
         callProvider(provider, "getInstallForURL", null,
                      aUrl, aHash, aName, aIcons, aVersion, aLoadGroup,
                      function  getInstallForURL_safeCall(aInstall) {
           safeCall(aCallback, aInstall);
         });
         return;
       }
     }
     safeCall(aCallback, null);
   },
   /**
    * Asynchronously gets an AddonInstall for an nsIFile.
    *
    * @param  aFile
    *         The nsIFile where the add-on is located
    * @param  aCallback
    *         A callback to pass the AddonInstall to
    * @param  aMimetype
    *         An optional mimetype hint for the add-on
    * @throws if the aFile or aCallback arguments are not specified
    */
   getInstallForFile: function AMI_getInstallForFile(aFile, aCallback, aMimetype) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!(aFile instanceof Ci.nsIFile))
       throw Components.Exception("aFile must be a nsIFile",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aMimetype && typeof aMimetype != "string")
       throw Components.Exception("aMimetype must be a string or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     new AsyncObjectCaller(this.providers, "getInstallForFile", {
       nextObject: function getInstallForFile_nextObject(aCaller, aProvider) {
         callProvider(aProvider, "getInstallForFile", null, aFile,
                      function getInstallForFile_safeCall(aInstall) {
           if (aInstall)
             safeCall(aCallback, aInstall);
           else
             aCaller.callNext();
         });
       },
       noMoreObjects: function getInstallForFile_noMoreObjects(aCaller) {
         safeCall(aCallback, null);
       }
     });
   },
   /**
    * Asynchronously gets all current AddonInstalls optionally limiting to a list
    * of types.
    *
    * @param  aTypes
    *         An optional array of types to retrieve. Each type is a string name
    * @param  aCallback
    *         A callback which will be passed an array of AddonInstalls
    * @throws If the aCallback argument is not specified
    */
   getInstallsByTypes: function AMI_getInstallsByTypes(aTypes, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (aTypes && !Array.isArray(aTypes))
       throw Components.Exception("aTypes must be an array or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     let installs = [];
     new AsyncObjectCaller(this.providers, "getInstallsByTypes", {
       nextObject: function getInstallsByTypes_nextObject(aCaller, aProvider) {
         callProvider(aProvider, "getInstallsByTypes", null, aTypes,
                      function getInstallsByTypes_safeCall(aProviderInstalls) {
           installs = installs.concat(aProviderInstalls);
           aCaller.callNext();
         });
       },
       noMoreObjects: function getInstallsByTypes_noMoreObjects(aCaller) {
         safeCall(aCallback, installs);
       }
     });
   },
   /**
    * Asynchronously gets all current AddonInstalls.
    *
    * @param  aCallback
    *         A callback which will be passed an array of AddonInstalls
    */
   getAllInstalls: function AMI_getAllInstalls(aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     this.getInstallsByTypes(null, aCallback);
   },
   /**
    * Synchronously map a URI to the corresponding Addon ID.
    *
    * Mappable URIs are limited to in-application resources belonging to the
    * add-on, such as Javascript compartments, XUL windows, XBL bindings, etc.
    * but do not include URIs from meta data, such as the add-on homepage.
    *
    * @param  aURI
    *         nsIURI to map to an addon id
    * @return string containing the Addon ID or null
    * @see    amIAddonManager.mapURIToAddonID
    */
   mapURIToAddonID: function AMI_mapURIToAddonID(aURI) {
     if (!(aURI instanceof Ci.nsIURI)) {
       throw Components.Exception("aURI is not a nsIURI",
                                  Cr.NS_ERROR_INVALID_ARG);
     }
     // Try all providers
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       var id = callProvider(provider, "mapURIToAddonID", null, aURI);
       if (id !== null) {
         return id;
       }
     }
     return null;
   },
   /**
    * Checks whether installation is enabled for a particular mimetype.
    *
    * @param  aMimetype
    *         The mimetype to check
    * @return true if installation is enabled for the mimetype
    */
   isInstallEnabled: function AMI_isInstallEnabled(aMimetype) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMimetype || typeof aMimetype != "string")
       throw Components.Exception("aMimetype must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       if (callProvider(provider, "supportsMimetype", false, aMimetype) &&
           callProvider(provider, "isInstallEnabled"))
         return true;
     }
     return false;
   },
   /**
    * Checks whether a particular source is allowed to install add-ons of a
    * given mimetype.
    *
    * @param  aMimetype
    *         The mimetype of the add-on
    * @param  aURI
    *         The optional nsIURI of the source
    * @return true if the source is allowed to install this mimetype
    */
   isInstallAllowed: function AMI_isInstallAllowed(aMimetype, aURI) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMimetype || typeof aMimetype != "string")
       throw Components.Exception("aMimetype must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aURI && !(aURI instanceof Ci.nsIURI))
       throw Components.Exception("aURI must be a nsIURI or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     let providers = this.providers.slice(0);
     for (let provider of providers) {
       if (callProvider(provider, "supportsMimetype", false, aMimetype) &&
           callProvider(provider, "isInstallAllowed", null, aURI))
         return true;
     }
     return false;
   },
   /**
    * Starts installation of an array of AddonInstalls notifying the registered
    * web install listener of blocked or started installs.
    *
    * @param  aMimetype
    *         The mimetype of add-ons being installed
    * @param  aSource
    *         The optional nsIDOMWindow that started the installs
    * @param  aURI
    *         The optional nsIURI that started the installs
    * @param  aInstalls
    *         The array of AddonInstalls to be installed
    */
   installAddonsFromWebpage: function AMI_installAddonsFromWebpage(aMimetype,
                                                                   aSource,
                                                                   aURI,
                                                                   aInstalls) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aMimetype || typeof aMimetype != "string")
       throw Components.Exception("aMimetype must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aSource && !(aSource instanceof Ci.nsIDOMWindow))
       throw Components.Exception("aSource must be a nsIDOMWindow or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (aURI && !(aURI instanceof Ci.nsIURI))
       throw Components.Exception("aURI must be a nsIURI or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!Array.isArray(aInstalls))
       throw Components.Exception("aInstalls must be an array",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!("@mozilla.org/addons/web-install-listener;1" in Cc)) {
       logger.warn("No web installer available, cancelling all installs");
       aInstalls.forEach(function(aInstall) {
         aInstall.cancel();
       });
       return;
     }
     try {
       let weblistener = Cc["@mozilla.org/addons/web-install-listener;1"].
                         getService(Ci.amIWebInstallListener);
       if (!this.isInstallEnabled(aMimetype, aURI)) {
         weblistener.onWebInstallDisabled(aSource, aURI, aInstalls,
                                          aInstalls.length);
       }
       else if (!this.isInstallAllowed(aMimetype, aURI)) {
         if (weblistener.onWebInstallBlocked(aSource, aURI, aInstalls,
                                             aInstalls.length)) {
           aInstalls.forEach(function(aInstall) {
             aInstall.install();
           });
         }
       }
       else if (weblistener.onWebInstallRequested(aSource, aURI, aInstalls,
                                                    aInstalls.length)) {
         aInstalls.forEach(function(aInstall) {
           aInstall.install();
         });
       }
     }
     catch (e) {
       // In the event that the weblistener throws during instantiation or when
       // calling onWebInstallBlocked or onWebInstallRequested all of the
       // installs should get cancelled.
       logger.warn("Failure calling web installer", e);
       aInstalls.forEach(function(aInstall) {
         aInstall.cancel();
       });
     }
   },
   /**
    * Adds a new InstallListener if the listener is not already registered.
    *
    * @param  aListener
    *         The InstallListener to add
    */
   addInstallListener: function AMI_addInstallListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be a InstallListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!this.installListeners.some(function addInstallListener_matchListener(i) {
       return i == aListener; }))
       this.installListeners.push(aListener);
   },
   /**
    * Removes an InstallListener if the listener is registered.
    *
    * @param  aListener
    *         The InstallListener to remove
    */
   removeInstallListener: function AMI_removeInstallListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be a InstallListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     let pos = 0;
     while (pos < this.installListeners.length) {
       if (this.installListeners[pos] == aListener)
         this.installListeners.splice(pos, 1);
       else
         pos++;
     }
   },
   /**
    * Asynchronously gets an add-on with a specific ID.
    *
    * @param  aID
    *         The ID of the add-on to retrieve
    * @param  aCallback
    *         The callback to pass the retrieved add-on to
    * @throws if the aID or aCallback arguments are not specified
    */
   getAddonByID: function AMI_getAddonByID(aID, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aID || typeof aID != "string")
       throw Components.Exception("aID must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     new AsyncObjectCaller(this.providers, "getAddonByID", {
       nextObject: function getAddonByID_nextObject(aCaller, aProvider) {
         callProvider(aProvider, "getAddonByID", null, aID,
                     function getAddonByID_safeCall(aAddon) {
           if (aAddon)
             safeCall(aCallback, aAddon);
           else
             aCaller.callNext();
         });
       },
       noMoreObjects: function getAddonByID_noMoreObjects(aCaller) {
         safeCall(aCallback, null);
       }
     });
   },
   /**
    * Asynchronously get an add-on with a specific Sync GUID.
    *
    * @param  aGUID
    *         String GUID of add-on to retrieve
    * @param  aCallback
    *         The callback to pass the retrieved add-on to.
    * @throws if the aGUID or aCallback arguments are not specified
    */
   getAddonBySyncGUID: function AMI_getAddonBySyncGUID(aGUID, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!aGUID || typeof aGUID != "string")
       throw Components.Exception("aGUID must be a non-empty string",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     new AsyncObjectCaller(this.providers, "getAddonBySyncGUID", {
       nextObject: function getAddonBySyncGUID_nextObject(aCaller, aProvider) {
         callProvider(aProvider, "getAddonBySyncGUID", null, aGUID,
                     function getAddonBySyncGUID_safeCall(aAddon) {
           if (aAddon) {
             safeCall(aCallback, aAddon);
           } else {
             aCaller.callNext();
           }
         });
       },
       noMoreObjects: function getAddonBySyncGUID_noMoreObjects(aCaller) {
         safeCall(aCallback, null);
       }
     });
   },
   /**
    * Asynchronously gets an array of add-ons.
    *
    * @param  aIDs
    *         The array of IDs to retrieve
    * @param  aCallback
    *         The callback to pass an array of Addons to
    * @throws if the aID or aCallback arguments are not specified
    */
   getAddonsByIDs: function AMI_getAddonsByIDs(aIDs, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (!Array.isArray(aIDs))
       throw Components.Exception("aIDs must be an array",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     let addons = [];
     new AsyncObjectCaller(aIDs, null, {
       nextObject: function getAddonsByIDs_nextObject(aCaller, aID) {
         AddonManagerInternal.getAddonByID(aID,
                              function getAddonsByIDs_getAddonByID(aAddon) {
           addons.push(aAddon);
           aCaller.callNext();
         });
       },
       noMoreObjects: function getAddonsByIDs_noMoreObjects(aCaller) {
         safeCall(aCallback, addons);
       }
     });
   },
   /**
    * Asynchronously gets add-ons of specific types.
    *
    * @param  aTypes
    *         An optional array of types to retrieve. Each type is a string name
    * @param  aCallback
    *         The callback to pass an array of Addons to.
    * @throws if the aCallback argument is not specified
    */
   getAddonsByTypes: function AMI_getAddonsByTypes(aTypes, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (aTypes && !Array.isArray(aTypes))
       throw Components.Exception("aTypes must be an array or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     let addons = [];
     new AsyncObjectCaller(this.providers, "getAddonsByTypes", {
       nextObject: function getAddonsByTypes_nextObject(aCaller, aProvider) {
         callProvider(aProvider, "getAddonsByTypes", null, aTypes,
                      function getAddonsByTypes_concatAddons(aProviderAddons) {
           addons = addons.concat(aProviderAddons);
           aCaller.callNext();
         });
       },
       noMoreObjects: function getAddonsByTypes_noMoreObjects(aCaller) {
         safeCall(aCallback, addons);
       }
     });
   },
   /**
    * Asynchronously gets all installed add-ons.
    *
    * @param  aCallback
    *         A callback which will be passed an array of Addons
    */
   getAllAddons: function AMI_getAllAddons(aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     this.getAddonsByTypes(null, aCallback);
   },
   /**
    * Asynchronously gets add-ons that have operations waiting for an application
    * restart to complete.
    *
    * @param  aTypes
    *         An optional array of types to retrieve. Each type is a string name
    * @param  aCallback
    *         The callback to pass the array of Addons to
    * @throws if the aCallback argument is not specified
    */
   getAddonsWithOperationsByTypes:
   function AMI_getAddonsWithOperationsByTypes(aTypes, aCallback) {
     if (!gStarted)
       throw Components.Exception("AddonManager is not initialized",
                                  Cr.NS_ERROR_NOT_INITIALIZED);
     if (aTypes && !Array.isArray(aTypes))
       throw Components.Exception("aTypes must be an array or null",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (typeof aCallback != "function")
       throw Components.Exception("aCallback must be a function",
                                  Cr.NS_ERROR_INVALID_ARG);
     let addons = [];
     new AsyncObjectCaller(this.providers, "getAddonsWithOperationsByTypes", {
       nextObject: function getAddonsWithOperationsByTypes_nextObject
                            (aCaller, aProvider) {
         callProvider(aProvider, "getAddonsWithOperationsByTypes", null, aTypes,
                      function getAddonsWithOperationsByTypes_concatAddons
                               (aProviderAddons) {
           addons = addons.concat(aProviderAddons);
           aCaller.callNext();
         });
       },
       noMoreObjects: function getAddonsWithOperationsByTypes_noMoreObjects(caller) {
         safeCall(aCallback, addons);
       }
     });
   },
   /**
    * Adds a new AddonManagerListener if the listener is not already registered.
    *
    * @param  aListener
    *         The listener to add
    */
   addManagerListener: function AMI_addManagerListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be an AddonManagerListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!this.managerListeners.some(function addManagerListener_matchListener(i) {
       return i == aListener; }))
       this.managerListeners.push(aListener);
   },
   /**
    * Removes an AddonManagerListener if the listener is registered.
    *
    * @param  aListener
    *         The listener to remove
    */
   removeManagerListener: function AMI_removeManagerListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be an AddonManagerListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     let pos = 0;
     while (pos < this.managerListeners.length) {
       if (this.managerListeners[pos] == aListener)
         this.managerListeners.splice(pos, 1);
       else
         pos++;
     }
   },
   /**
    * Adds a new AddonListener if the listener is not already registered.
    *
    * @param  aListener
    *         The AddonListener to add
    */
   addAddonListener: function AMI_addAddonListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be an AddonListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!this.addonListeners.some(function addAddonListener_matchListener(i) {
       return i == aListener; }))
       this.addonListeners.push(aListener);
   },
   /**
    * Removes an AddonListener if the listener is registered.
    *
    * @param  aListener
    *         The AddonListener to remove
    */
   removeAddonListener: function AMI_removeAddonListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be an AddonListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     let pos = 0;
     while (pos < this.addonListeners.length) {
       if (this.addonListeners[pos] == aListener)
         this.addonListeners.splice(pos, 1);
       else
         pos++;
     }
   },
   /**
    * Adds a new TypeListener if the listener is not already registered.
    *
    * @param  aListener
    *         The TypeListener to add
    */
   addTypeListener: function AMI_addTypeListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be a TypeListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!this.typeListeners.some(function addTypeListener_matchListener(i) {
       return i == aListener; }))
       this.typeListeners.push(aListener);
   },
   /**
    * Removes an TypeListener if the listener is registered.
    *
    * @param  aListener
    *         The TypeListener to remove
    */
   removeTypeListener: function AMI_removeTypeListener(aListener) {
     if (!aListener || typeof aListener != "object")
       throw Components.Exception("aListener must be a TypeListener object",
                                  Cr.NS_ERROR_INVALID_ARG);
     let pos = 0;
     while (pos < this.typeListeners.length) {
       if (this.typeListeners[pos] == aListener)
         this.typeListeners.splice(pos, 1);
       else
         pos++;
     }
   },
   get addonTypes() {
     return this.typesProxy;
   },
   get autoUpdateDefault() {
     return gAutoUpdateDefault;
   },
   set autoUpdateDefault(aValue) {
     aValue = !!aValue;
     if (aValue != gAutoUpdateDefault)
       Services.prefs.setBoolPref(PREF_EM_AUTOUPDATE_DEFAULT, aValue);
     return aValue;
   },
   get checkCompatibility() {
     return gCheckCompatibility;
   },
   set checkCompatibility(aValue) {
     aValue = !!aValue;
     if (aValue != gCheckCompatibility) {
       if (!aValue)
         Services.prefs.setBoolPref(PREF_EM_CHECK_COMPATIBILITY, false);
       else
         Services.prefs.clearUserPref(PREF_EM_CHECK_COMPATIBILITY);
     }
     return aValue;
   },
   get strictCompatibility() {
     return gStrictCompatibility;
   },
   set strictCompatibility(aValue) {
     aValue = !!aValue;
     if (aValue != gStrictCompatibility)
       Services.prefs.setBoolPref(PREF_EM_STRICT_COMPATIBILITY, aValue);
     return aValue;
   },
   get checkUpdateSecurityDefault() {
     return gCheckUpdateSecurityDefault;
   },
   get checkUpdateSecurity() {
     return gCheckUpdateSecurity;
   },
   set checkUpdateSecurity(aValue) {
     aValue = !!aValue;
     if (aValue != gCheckUpdateSecurity) {
       if (aValue != gCheckUpdateSecurityDefault)
         Services.prefs.setBoolPref(PREF_EM_CHECK_UPDATE_SECURITY, aValue);
       else
         Services.prefs.clearUserPref(PREF_EM_CHECK_UPDATE_SECURITY);
     }
     return aValue;
   },
   get updateEnabled() {
     return gUpdateEnabled;
   },
   set updateEnabled(aValue) {
     aValue = !!aValue;
     if (aValue != gUpdateEnabled)
       Services.prefs.setBoolPref(PREF_EM_UPDATE_ENABLED, aValue);
     return aValue;
   },
   get hotfixID() {
     return gHotfixID;
   },
 };
 /**
  * Should not be used outside of core Mozilla code. This is a private API for
  * the startup and platform integration code to use. Refer to the methods on
  * AddonManagerInternal for documentation however note that these methods are
  * subject to change at any time.
  */
 this.AddonManagerPrivate = {
   startup: function AMP_startup() {
     AddonManagerInternal.startup();
   },
   registerProvider: function AMP_registerProvider(aProvider, aTypes) {
     AddonManagerInternal.registerProvider(aProvider, aTypes);
   },
   unregisterProvider: function AMP_unregisterProvider(aProvider) {
     AddonManagerInternal.unregisterProvider(aProvider);
   },
   backgroundUpdateCheck: function AMP_backgroundUpdateCheck() {
     AddonManagerInternal.backgroundUpdateCheck();
   },
   addStartupChange: function AMP_addStartupChange(aType, aID) {
     AddonManagerInternal.addStartupChange(aType, aID);
   },
   removeStartupChange: function AMP_removeStartupChange(aType, aID) {
     AddonManagerInternal.removeStartupChange(aType, aID);
   },
   notifyAddonChanged: function AMP_notifyAddonChanged(aID, aType, aPendingRestart) {
     AddonManagerInternal.notifyAddonChanged(aID, aType, aPendingRestart);
   },
   updateAddonAppDisabledStates: function AMP_updateAddonAppDisabledStates() {
     AddonManagerInternal.updateAddonAppDisabledStates();
   },
   updateAddonRepositoryData: function AMP_updateAddonRepositoryData(aCallback) {
     AddonManagerInternal.updateAddonRepositoryData(aCallback);
   },
   callInstallListeners: function AMP_callInstallListeners(...aArgs) {
     return AddonManagerInternal.callInstallListeners.apply(AddonManagerInternal,
                                                            aArgs);
   },
   callAddonListeners: function AMP_callAddonListeners(...aArgs) {
     AddonManagerInternal.callAddonListeners.apply(AddonManagerInternal, aArgs);
   },
   AddonAuthor: AddonAuthor,
   AddonScreenshot: AddonScreenshot,
   AddonCompatibilityOverride: AddonCompatibilityOverride,
   AddonType: AddonType,
   recordTimestamp: function AMP_recordTimestamp(name, value) {
     AddonManagerInternal.recordTimestamp(name, value);
   },
   _simpleMeasures: {},
   recordSimpleMeasure: function AMP_recordSimpleMeasure(name, value) {
     this._simpleMeasures[name] = value;
   },
   recordException: function AMP_recordException(aModule, aContext, aException) {
     let report = {
       module: aModule,
       context: aContext
     };
     if (typeof aException == "number") {
       report.message = Components.Exception("", aException).name;
     }
     else {
       report.message = aException.toString();
       if (aException.fileName) {
         report.file = aException.fileName;
         report.line = aException.lineNumber;
       }
     }
     this._simpleMeasures.exception = report;
   },
   getSimpleMeasures: function AMP_getSimpleMeasures() {
     return this._simpleMeasures;
   },
   getTelemetryDetails: function AMP_getTelemetryDetails() {
     return AddonManagerInternal.telemetryDetails;
   },
   setTelemetryDetails: function AMP_setTelemetryDetails(aProvider, aDetails) {
     AddonManagerInternal.telemetryDetails[aProvider] = aDetails;
   },
   // Start a timer, record a simple measure of the time interval when
   // timer.done() is called
   simpleTimer: function(aName) {
     let startTime = Date.now();
     return {
       done: () => this.recordSimpleMeasure(aName, Date.now() - startTime)
     };
   },
   /**
    * Helper to call update listeners when no update is available.
    *
    * This can be used as an implementation for Addon.findUpdates() when
    * no update mechanism is available.
    */
   callNoUpdateListeners: function (addon, listener, reason, appVersion, platformVersion) {
     if ("onNoCompatibilityUpdateAvailable" in listener) {
       safeCall(listener.onNoCompatibilityUpdateAvailable.bind(listener), addon);
     }
     if ("onNoUpdateAvailable" in listener) {
       safeCall(listener.onNoUpdateAvailable.bind(listener), addon);
     }
     if ("onUpdateFinished" in listener) {
       safeCall(listener.onUpdateFinished.bind(listener), addon);
     }
   },
 };
 /**
  * This is the public API that UI and developers should be calling. All methods
  * just forward to AddonManagerInternal.
  */
 this.AddonManager = {
   // Constants for the AddonInstall.state property
   // The install is available for download.
   STATE_AVAILABLE: 0,
   // The install is being downloaded.
   STATE_DOWNLOADING: 1,
   // The install is checking for compatibility information.
   STATE_CHECKING: 2,
   // The install is downloaded and ready to install.
   STATE_DOWNLOADED: 3,
   // The download failed.
   STATE_DOWNLOAD_FAILED: 4,
   // The add-on is being installed.
   STATE_INSTALLING: 5,
   // The add-on has been installed.
   STATE_INSTALLED: 6,
   // The install failed.
   STATE_INSTALL_FAILED: 7,
   // The install has been cancelled.
   STATE_CANCELLED: 8,
   // Constants representing different types of errors while downloading an
   // add-on.
   // The download failed due to network problems.
   ERROR_NETWORK_FAILURE: -1,
   // The downloaded file did not match the provided hash.
   ERROR_INCORRECT_HASH: -2,
   // The downloaded file seems to be corrupted in some way.
   ERROR_CORRUPT_FILE: -3,
   // An error occured trying to write to the filesystem.
   ERROR_FILE_ACCESS: -4,
   // These must be kept in sync with AddonUpdateChecker.
   // No error was encountered.
   UPDATE_STATUS_NO_ERROR: 0,
   // The update check timed out
   UPDATE_STATUS_TIMEOUT: -1,
   // There was an error while downloading the update information.
   UPDATE_STATUS_DOWNLOAD_ERROR: -2,
   // The update information was malformed in some way.
   UPDATE_STATUS_PARSE_ERROR: -3,
   // The update information was not in any known format.
   UPDATE_STATUS_UNKNOWN_FORMAT: -4,
   // The update information was not correctly signed or there was an SSL error.
   UPDATE_STATUS_SECURITY_ERROR: -5,
   // The update was cancelled.
   UPDATE_STATUS_CANCELLED: -6,
   // Constants to indicate why an update check is being performed
   // Update check has been requested by the user.
   UPDATE_WHEN_USER_REQUESTED: 1,
   // Update check is necessary to see if the Addon is compatibile with a new
   // version of the application.
   UPDATE_WHEN_NEW_APP_DETECTED: 2,
   // Update check is necessary because a new application has been installed.
   UPDATE_WHEN_NEW_APP_INSTALLED: 3,
   // Update check is a regular background update check.
   UPDATE_WHEN_PERIODIC_UPDATE: 16,
   // Update check is needed to check an Addon that is being installed.
   UPDATE_WHEN_ADDON_INSTALLED: 17,
   // Constants for operations in Addon.pendingOperations
   // Indicates that the Addon has no pending operations.
   PENDING_NONE: 0,
   // Indicates that the Addon will be enabled after the application restarts.
   PENDING_ENABLE: 1,
   // Indicates that the Addon will be disabled after the application restarts.
   PENDING_DISABLE: 2,
   // Indicates that the Addon will be uninstalled after the application restarts.
   PENDING_UNINSTALL: 4,
   // Indicates that the Addon will be installed after the application restarts.
   PENDING_INSTALL: 8,
   PENDING_UPGRADE: 16,
   // Constants for operations in Addon.operationsRequiringRestart
   // Indicates that restart isn't required for any operation.
   OP_NEEDS_RESTART_NONE: 0,
   // Indicates that restart is required for enabling the addon.
   OP_NEEDS_RESTART_ENABLE: 1,
   // Indicates that restart is required for disabling the addon.
   OP_NEEDS_RESTART_DISABLE: 2,
   // Indicates that restart is required for uninstalling the addon.
   OP_NEEDS_RESTART_UNINSTALL: 4,
   // Indicates that restart is required for installing the addon.
   OP_NEEDS_RESTART_INSTALL: 8,
   // Constants for permissions in Addon.permissions.
   // Indicates that the Addon can be uninstalled.
   PERM_CAN_UNINSTALL: 1,
   // Indicates that the Addon can be enabled by the user.
   PERM_CAN_ENABLE: 2,
   // Indicates that the Addon can be disabled by the user.
   PERM_CAN_DISABLE: 4,
   // Indicates that the Addon can be upgraded.
   PERM_CAN_UPGRADE: 8,
   // Indicates that the Addon can be set to be optionally enabled
   // on a case-by-case basis.
   PERM_CAN_ASK_TO_ACTIVATE: 16,
   // General descriptions of where items are installed.
   // Installed in this profile.
   SCOPE_PROFILE: 1,
   // Installed for all of this user's profiles.
   SCOPE_USER: 2,
   // Installed and owned by the application.
   SCOPE_APPLICATION: 4,
   // Installed for all users of the computer.
   SCOPE_SYSTEM: 8,
   // The combination of all scopes.
   SCOPE_ALL: 15,
   // 1-15 are different built-in views for the add-on type
   VIEW_TYPE_LIST: "list",
   TYPE_UI_HIDE_EMPTY: 16,
   // Indicates that this add-on type supports the ask-to-activate state.
   // That is, add-ons of this type can be set to be optionally enabled
   // on a case-by-case basis.
   TYPE_SUPPORTS_ASK_TO_ACTIVATE: 32,
   // Constants for Addon.applyBackgroundUpdates.
   // Indicates that the Addon should not update automatically.
   AUTOUPDATE_DISABLE: 0,
   // Indicates that the Addon should update automatically only if
   // that's the global default.
   AUTOUPDATE_DEFAULT: 1,
   // Indicates that the Addon should update automatically.
   AUTOUPDATE_ENABLE: 2,
   // Constants for how Addon options should be shown.
   // Options will be opened in a new window
   OPTIONS_TYPE_DIALOG: 1,
   // Options will be displayed within the AM detail view
   OPTIONS_TYPE_INLINE: 2,
   // Options will be displayed in a new tab, if possible
   OPTIONS_TYPE_TAB: 3,
   // Same as OPTIONS_TYPE_INLINE, but no Preferences button will be shown.
   // Used to indicate that only non-interactive information will be shown.
   OPTIONS_TYPE_INLINE_INFO: 4,
   // Constants for displayed or hidden options notifications
   // Options notification will be displayed
   OPTIONS_NOTIFICATION_DISPLAYED: "addon-options-displayed",
   // Options notification will be hidden
   OPTIONS_NOTIFICATION_HIDDEN: "addon-options-hidden",
   // Constants for getStartupChanges, addStartupChange and removeStartupChange
   // Add-ons that were detected as installed during startup. Doesn't include
   // add-ons that were pending installation the last time the application ran.
   STARTUP_CHANGE_INSTALLED: "installed",
   // Add-ons that were detected as changed during startup. This includes an
   // add-on moving to a different location, changing version or just having
   // been detected as possibly changed.
   STARTUP_CHANGE_CHANGED: "changed",
   // Add-ons that were detected as uninstalled during startup. Doesn't include
   // add-ons that were pending uninstallation the last time the application ran.
   STARTUP_CHANGE_UNINSTALLED: "uninstalled",
   // Add-ons that were detected as disabled during startup, normally because of
   // an application change making an add-on incompatible. Doesn't include
   // add-ons that were pending being disabled the last time the application ran.
   STARTUP_CHANGE_DISABLED: "disabled",
   // Add-ons that were detected as enabled during startup, normally because of
   // an application change making an add-on compatible. Doesn't include
   // add-ons that were pending being enabled the last time the application ran.
   STARTUP_CHANGE_ENABLED: "enabled",
   // Constants for the Addon.userDisabled property
   // Indicates that the userDisabled state of this add-on is currently
   // ask-to-activate. That is, it can be conditionally enabled on a
   // case-by-case basis.
   STATE_ASK_TO_ACTIVATE: "askToActivate",
 #ifdef MOZ_EM_DEBUG
   get __AddonManagerInternal__() {
     return AddonManagerInternal;
   },
 #endif
   getInstallForURL: function AM_getInstallForURL(aUrl, aCallback, aMimetype,
                                                  aHash, aName, aIcons,
                                                  aVersion, aLoadGroup) {
     AddonManagerInternal.getInstallForURL(aUrl, aCallback, aMimetype, aHash,
                                           aName, aIcons, aVersion, aLoadGroup);
   },
   getInstallForFile: function AM_getInstallForFile(aFile, aCallback, aMimetype) {
     AddonManagerInternal.getInstallForFile(aFile, aCallback, aMimetype);
   },
   /**
    * Gets an array of add-on IDs that changed during the most recent startup.
    *
    * @param  aType
    *         The type of startup change to get
    * @return An array of add-on IDs
    */
   getStartupChanges: function AM_getStartupChanges(aType) {
     if (!(aType in AddonManagerInternal.startupChanges))
       return [];
     return AddonManagerInternal.startupChanges[aType].slice(0);
   },
   getAddonByID: function AM_getAddonByID(aID, aCallback) {
     AddonManagerInternal.getAddonByID(aID, aCallback);
   },
   getAddonBySyncGUID: function AM_getAddonBySyncGUID(aGUID, aCallback) {
     AddonManagerInternal.getAddonBySyncGUID(aGUID, aCallback);
   },
   getAddonsByIDs: function AM_getAddonsByIDs(aIDs, aCallback) {
     AddonManagerInternal.getAddonsByIDs(aIDs, aCallback);
   },
   getAddonsWithOperationsByTypes:
   function AM_getAddonsWithOperationsByTypes(aTypes, aCallback) {
     AddonManagerInternal.getAddonsWithOperationsByTypes(aTypes, aCallback);
   },
   getAddonsByTypes: function AM_getAddonsByTypes(aTypes, aCallback) {
     AddonManagerInternal.getAddonsByTypes(aTypes, aCallback);
   },
   getAllAddons: function AM_getAllAddons(aCallback) {
     AddonManagerInternal.getAllAddons(aCallback);
   },
   getInstallsByTypes: function AM_getInstallsByTypes(aTypes, aCallback) {
     AddonManagerInternal.getInstallsByTypes(aTypes, aCallback);
   },
   getAllInstalls: function AM_getAllInstalls(aCallback) {
     AddonManagerInternal.getAllInstalls(aCallback);
   },
   mapURIToAddonID: function AM_mapURIToAddonID(aURI) {
     return AddonManagerInternal.mapURIToAddonID(aURI);
   },
   isInstallEnabled: function AM_isInstallEnabled(aType) {
     return AddonManagerInternal.isInstallEnabled(aType);
   },
   isInstallAllowed: function AM_isInstallAllowed(aType, aUri) {
     return AddonManagerInternal.isInstallAllowed(aType, aUri);
   },
   installAddonsFromWebpage: function AM_installAddonsFromWebpage(aType, aSource,
                                                                  aUri, aInstalls) {
     AddonManagerInternal.installAddonsFromWebpage(aType, aSource, aUri, aInstalls);
   },
   addManagerListener: function AM_addManagerListener(aListener) {
     AddonManagerInternal.addManagerListener(aListener);
   },
   removeManagerListener: function AM_removeManagerListener(aListener) {
     AddonManagerInternal.removeManagerListener(aListener);
   },
   addInstallListener: function AM_addInstallListener(aListener) {
     AddonManagerInternal.addInstallListener(aListener);
   },
   removeInstallListener: function AM_removeInstallListener(aListener) {
     AddonManagerInternal.removeInstallListener(aListener);
   },
   addAddonListener: function AM_addAddonListener(aListener) {
     AddonManagerInternal.addAddonListener(aListener);
   },
   removeAddonListener: function AM_removeAddonListener(aListener) {
     AddonManagerInternal.removeAddonListener(aListener);
   },
   addTypeListener: function AM_addTypeListener(aListener) {
     AddonManagerInternal.addTypeListener(aListener);
   },
   removeTypeListener: function AM_removeTypeListener(aListener) {
     AddonManagerInternal.removeTypeListener(aListener);
   },
   get addonTypes() {
     return AddonManagerInternal.addonTypes;
   },
   /**
    * Determines whether an Addon should auto-update or not.
    *
    * @param  aAddon
    *         The Addon representing the add-on
    * @return true if the addon should auto-update, false otherwise.
    */
   shouldAutoUpdate: function AM_shouldAutoUpdate(aAddon) {
     if (!aAddon || typeof aAddon != "object")
       throw Components.Exception("aAddon must be specified",
                                  Cr.NS_ERROR_INVALID_ARG);
     if (!("applyBackgroundUpdates" in aAddon))
       return false;
     if (aAddon.applyBackgroundUpdates == AddonManager.AUTOUPDATE_ENABLE)
       return true;
     if (aAddon.applyBackgroundUpdates == AddonManager.AUTOUPDATE_DISABLE)
       return false;
     return this.autoUpdateDefault;
   },
   get checkCompatibility() {
     return AddonManagerInternal.checkCompatibility;
   },
   set checkCompatibility(aValue) {
     AddonManagerInternal.checkCompatibility = aValue;
   },
   get strictCompatibility() {
     return AddonManagerInternal.strictCompatibility;
   },
   set strictCompatibility(aValue) {
     AddonManagerInternal.strictCompatibility = aValue;
   },
   get checkUpdateSecurityDefault() {
     return AddonManagerInternal.checkUpdateSecurityDefault;
   },
   get checkUpdateSecurity() {
     return AddonManagerInternal.checkUpdateSecurity;
   },
   set checkUpdateSecurity(aValue) {
     AddonManagerInternal.checkUpdateSecurity = aValue;
   },
   get updateEnabled() {
     return AddonManagerInternal.updateEnabled;
   },
   set updateEnabled(aValue) {
     AddonManagerInternal.updateEnabled = aValue;
   },
   get autoUpdateDefault() {
     return AddonManagerInternal.autoUpdateDefault;
   },
   set autoUpdateDefault(aValue) {
     AddonManagerInternal.autoUpdateDefault = aValue;
   },
   get hotfixID() {
     return AddonManagerInternal.hotfixID;
   },
   escapeAddonURI: function AM_escapeAddonURI(aAddon, aUri, aAppVersion) {
     return AddonManagerInternal.escapeAddonURI(aAddon, aUri, aAppVersion);
   }
 };
 // load the timestamps module into AddonManagerInternal
 Cu.import("resource://gre/modules/TelemetryTimestamps.jsm", AddonManagerInternal);
 Object.freeze(AddonManagerInternal);
 Object.freeze(AddonManagerPrivate);
 Object.freeze(AddonManager);

The Tor Browser / annotate

toolkit/mozapps/extensions/AddonManager.jsm@129ffea94266 (annotated)

toolkit/mozapps/extensions/AddonManager.jsm