The Tor Browser / file revision

 /* 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 [];