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

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

toolkit/mozapps/extensions/internal/XPIProvider.jsm

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

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

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

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 "use strict";
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 this.EXPORTED_SYMBOLS = ["XPIProvider"];
 Components.utils.import("resource://gre/modules/Services.jsm");
 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 Components.utils.import("resource://gre/modules/AddonManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository",
                                   "resource://gre/modules/addons/AddonRepository.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ChromeManifestParser",
                                   "resource://gre/modules/ChromeManifestParser.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "LightweightThemeManager",
                                   "resource://gre/modules/LightweightThemeManager.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
                                   "resource://gre/modules/FileUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "ZipUtils",
                                   "resource://gre/modules/ZipUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
                                   "resource://gre/modules/NetUtil.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PermissionsUtils",
                                   "resource://gre/modules/PermissionsUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Task",
                                   "resource://gre/modules/Task.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "OS",
                                   "resource://gre/modules/osfile.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "BrowserToolboxProcess",
                                   "resource:///modules/devtools/ToolboxProcess.jsm");
 XPCOMUtils.defineLazyServiceGetter(this,
                                    "ChromeRegistry",
                                    "@mozilla.org/chrome/chrome-registry;1",
                                    "nsIChromeRegistry");
 XPCOMUtils.defineLazyServiceGetter(this,
                                    "ResProtocolHandler",
                                    "@mozilla.org/network/protocol;1?name=resource",
                                    "nsIResProtocolHandler");
 const nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile",
                                        "initWithPath");
 const PREF_DB_SCHEMA                  = "extensions.databaseSchema";
 const PREF_INSTALL_CACHE              = "extensions.installCache";
 const PREF_BOOTSTRAP_ADDONS           = "extensions.bootstrappedAddons";
 const PREF_PENDING_OPERATIONS         = "extensions.pendingOperations";
 const PREF_MATCH_OS_LOCALE            = "intl.locale.matchOS";
 const PREF_SELECTED_LOCALE            = "general.useragent.locale";
 const PREF_EM_DSS_ENABLED             = "extensions.dss.enabled";
 const PREF_DSS_SWITCHPENDING          = "extensions.dss.switchPending";
 const PREF_DSS_SKIN_TO_SELECT         = "extensions.lastSelectedSkin";
 const PREF_GENERAL_SKINS_SELECTEDSKIN = "general.skins.selectedSkin";
 const PREF_EM_UPDATE_URL              = "extensions.update.url";
 const PREF_EM_UPDATE_BACKGROUND_URL   = "extensions.update.background.url";
 const PREF_EM_ENABLED_ADDONS          = "extensions.enabledAddons";
 const PREF_EM_EXTENSION_FORMAT        = "extensions.";
 const PREF_EM_ENABLED_SCOPES          = "extensions.enabledScopes";
 const PREF_EM_AUTO_DISABLED_SCOPES    = "extensions.autoDisableScopes";
 const PREF_EM_SHOW_MISMATCH_UI        = "extensions.showMismatchUI";
 const PREF_XPI_ENABLED                = "xpinstall.enabled";
 const PREF_XPI_WHITELIST_REQUIRED     = "xpinstall.whitelist.required";
 const PREF_XPI_DIRECT_WHITELISTED     = "xpinstall.whitelist.directRequest";
 const PREF_XPI_FILE_WHITELISTED       = "xpinstall.whitelist.fileRequest";
 const PREF_XPI_PERMISSIONS_BRANCH     = "xpinstall.";
 const PREF_XPI_UNPACK                 = "extensions.alwaysUnpack";
 const PREF_INSTALL_REQUIREBUILTINCERTS = "extensions.install.requireBuiltInCerts";
 const PREF_INSTALL_DISTRO_ADDONS      = "extensions.installDistroAddons";
 const PREF_BRANCH_INSTALLED_ADDON     = "extensions.installedDistroAddon.";
 const PREF_SHOWN_SELECTION_UI         = "extensions.shownSelectionUI";
 const PREF_EM_MIN_COMPAT_APP_VERSION      = "extensions.minCompatibleAppVersion";
 const PREF_EM_MIN_COMPAT_PLATFORM_VERSION = "extensions.minCompatiblePlatformVersion";
 const PREF_CHECKCOMAT_THEMEOVERRIDE   = "extensions.checkCompatibility.temporaryThemeOverride_minAppVersion";
 const URI_EXTENSION_SELECT_DIALOG     = "chrome://mozapps/content/extensions/selectAddons.xul";
 const URI_EXTENSION_UPDATE_DIALOG     = "chrome://mozapps/content/extensions/update.xul";
 const URI_EXTENSION_STRINGS           = "chrome://mozapps/locale/extensions/extensions.properties";
 const STRING_TYPE_NAME                = "type.%ID%.name";
 const DIR_EXTENSIONS                  = "extensions";
 const DIR_STAGE                       = "staged";
 const DIR_XPI_STAGE                   = "staged-xpis";
 const DIR_TRASH                       = "trash";
 const FILE_DATABASE                   = "extensions.json";
 const FILE_OLD_CACHE                  = "extensions.cache";
 const FILE_INSTALL_MANIFEST           = "install.rdf";
 const FILE_XPI_ADDONS_LIST            = "extensions.ini";
 const KEY_PROFILEDIR                  = "ProfD";
 const KEY_APPDIR                      = "XCurProcD";
 const KEY_TEMPDIR                     = "TmpD";
 const KEY_APP_DISTRIBUTION            = "XREAppDist";
 const KEY_APP_PROFILE                 = "app-profile";
 const KEY_APP_GLOBAL                  = "app-global";
 const KEY_APP_SYSTEM_LOCAL            = "app-system-local";
 const KEY_APP_SYSTEM_SHARE            = "app-system-share";
 const KEY_APP_SYSTEM_USER             = "app-system-user";
 const NOTIFICATION_FLUSH_PERMISSIONS  = "flush-pending-permissions";
 const XPI_PERMISSION                  = "install";
 const RDFURI_INSTALL_MANIFEST_ROOT    = "urn:mozilla:install-manifest";
 const PREFIX_NS_EM                    = "http://www.mozilla.org/2004/em-rdf#";
 const TOOLKIT_ID                      = "toolkit@mozilla.org";
 // The value for this is in Makefile.in
 #expand const DB_SCHEMA                       = __MOZ_EXTENSIONS_DB_SCHEMA__;
 // Properties that exist in the install manifest
 const PROP_METADATA      = ["id", "version", "type", "internalName", "updateURL",
                             "updateKey", "optionsURL", "optionsType", "aboutURL",
                             "iconURL", "icon64URL"];
 const PROP_LOCALE_SINGLE = ["name", "description", "creator", "homepageURL"];
 const PROP_LOCALE_MULTI  = ["developers", "translators", "contributors"];
 const PROP_TARGETAPP     = ["id", "minVersion", "maxVersion"];
 // Properties that should be migrated where possible from an old database. These
 // shouldn't include properties that can be read directly from install.rdf files
 // or calculated
 const DB_MIGRATE_METADATA= ["installDate", "userDisabled", "softDisabled",
                             "sourceURI", "applyBackgroundUpdates",
                             "releaseNotesURI", "foreignInstall", "syncGUID"];
 // Properties to cache and reload when an addon installation is pending
 const PENDING_INSTALL_METADATA =
     ["syncGUID", "targetApplications", "userDisabled", "softDisabled",
      "existingAddonID", "sourceURI", "releaseNotesURI", "installDate",
      "updateDate", "applyBackgroundUpdates", "compatibilityOverrides"];
 // Note: When adding/changing/removing items here, remember to change the
 // DB schema version to ensure changes are picked up ASAP.
 const STATIC_BLOCKLIST_PATTERNS = [
   { creator: "Mozilla Corp.",
     level: Ci.nsIBlocklistService.STATE_BLOCKED,
     blockID: "i162" },
   { creator: "Mozilla.org",
     level: Ci.nsIBlocklistService.STATE_BLOCKED,
     blockID: "i162" }
 ];
 const BOOTSTRAP_REASONS = {
   APP_STARTUP     : 1,
   APP_SHUTDOWN    : 2,
   ADDON_ENABLE    : 3,
   ADDON_DISABLE   : 4,
   ADDON_INSTALL   : 5,
   ADDON_UNINSTALL : 6,
   ADDON_UPGRADE   : 7,
   ADDON_DOWNGRADE : 8
 };
 // Map new string type identifiers to old style nsIUpdateItem types
 const TYPES = {
   extension: 2,
   theme: 4,
   locale: 8,
   multipackage: 32,
   dictionary: 64,
   experiment: 128,
 };
 const RESTARTLESS_TYPES = new Set([
   "dictionary",
   "experiment",
   "locale",
 ]);
 // Keep track of where we are in startup for telemetry
 // event happened during XPIDatabase.startup()
 const XPI_STARTING = "XPIStarting";
 // event happened after startup() but before the final-ui-startup event
 const XPI_BEFORE_UI_STARTUP = "BeforeFinalUIStartup";
 // event happened after final-ui-startup
 const XPI_AFTER_UI_STARTUP = "AfterFinalUIStartup";
 const COMPATIBLE_BY_DEFAULT_TYPES = {
   extension: true,
   dictionary: true
 };
 const MSG_JAR_FLUSH = "AddonJarFlush";
 var gGlobalScope = this;
 /**
  * Valid IDs fit this pattern.
  */
 var gIDTest = /^(\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}|[a-z0-9-\._]*\@[a-z0-9-\._]+)$/i;
 Cu.import("resource://gre/modules/Log.jsm");
 const LOGGER_ID = "addons.xpi";
 // Create a new logger for use by all objects in this Addons XPI Provider module
 // (Requires AddonManager.jsm)
 let logger = Log.repository.getLogger(LOGGER_ID);
 const LAZY_OBJECTS = ["XPIDatabase"];
 var gLazyObjectsLoaded = false;
 function loadLazyObjects() {
   let scope = {};
   scope.AddonInternal = AddonInternal;
   scope.XPIProvider = XPIProvider;
   Services.scriptloader.loadSubScript("resource://gre/modules/addons/XPIProviderUtils.js",
                                       scope);
   for (let name of LAZY_OBJECTS) {
     delete gGlobalScope[name];
     gGlobalScope[name] = scope[name];
   }
   gLazyObjectsLoaded = true;
   return scope;
 }
 for (let name of LAZY_OBJECTS) {
   Object.defineProperty(gGlobalScope, name, {
     get: function lazyObjectGetter() {
       let objs = loadLazyObjects();
       return objs[name];
     },
     configurable: true
   });
 }
 function findMatchingStaticBlocklistItem(aAddon) {
   for (let item of STATIC_BLOCKLIST_PATTERNS) {
     if ("creator" in item && typeof item.creator == "string") {
       if ((aAddon.defaultLocale && aAddon.defaultLocale.creator == item.creator) ||
           (aAddon.selectedLocale && aAddon.selectedLocale.creator == item.creator)) {
         return item;
       }
     }
   }
   return null;
 }
 /**
  * Sets permissions on a file
  *
  * @param  aFile
  *         The file or directory to operate on.
  * @param  aPermissions
  *         The permisions to set
  */
 function setFilePermissions(aFile, aPermissions) {
   try {
     aFile.permissions = aPermissions;
   }
   catch (e) {
     logger.warn("Failed to set permissions " + aPermissions.toString(8) + " on " +
          aFile.path, e);
   }
 }
 /**
  * A safe way to install a file or the contents of a directory to a new
  * directory. The file or directory is moved or copied recursively and if
  * anything fails an attempt is made to rollback the entire operation. The
  * operation may also be rolled back to its original state after it has
  * completed by calling the rollback method.
  *
  * Operations can be chained. Calling move or copy multiple times will remember
  * the whole set and if one fails all of the operations will be rolled back.
  */
 function SafeInstallOperation() {
   this._installedFiles = [];
   this._createdDirs = [];
 }
 SafeInstallOperation.prototype = {
   _installedFiles: null,
   _createdDirs: null,
   _installFile: function SIO_installFile(aFile, aTargetDirectory, aCopy) {
     let oldFile = aCopy ? null : aFile.clone();
     let newFile = aFile.clone();
     try {
       if (aCopy)
         newFile.copyTo(aTargetDirectory, null);
       else
         newFile.moveTo(aTargetDirectory, null);
     }
     catch (e) {
       logger.error("Failed to " + (aCopy ? "copy" : "move") + " file " + aFile.path +
             " to " + aTargetDirectory.path, e);
       throw e;
     }
     this._installedFiles.push({ oldFile: oldFile, newFile: newFile });
   },
   _installDirectory: function SIO_installDirectory(aDirectory, aTargetDirectory, aCopy) {
     let newDir = aTargetDirectory.clone();
     newDir.append(aDirectory.leafName);
     try {
       newDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
     }
     catch (e) {
       logger.error("Failed to create directory " + newDir.path, e);
       throw e;
     }
     this._createdDirs.push(newDir);
     // Use a snapshot of the directory contents to avoid possible issues with
     // iterating over a directory while removing files from it (the YAFFS2
     // embedded filesystem has this issue, see bug 772238), and to remove
     // normal files before their resource forks on OSX (see bug 733436).
     let entries = getDirectoryEntries(aDirectory, true);
     entries.forEach(function(aEntry) {
       try {
         this._installDirEntry(aEntry, newDir, aCopy);
       }
       catch (e) {
         logger.error("Failed to " + (aCopy ? "copy" : "move") + " entry " +
               aEntry.path, e);
         throw e;
       }
     }, this);
     // If this is only a copy operation then there is nothing else to do
     if (aCopy)
       return;
     // The directory should be empty by this point. If it isn't this will throw
     // and all of the operations will be rolled back
     try {
       setFilePermissions(aDirectory, FileUtils.PERMS_DIRECTORY);
       aDirectory.remove(false);
     }
     catch (e) {
       logger.error("Failed to remove directory " + aDirectory.path, e);
       throw e;
     }
     // Note we put the directory move in after all the file moves so the
     // directory is recreated before all the files are moved back
     this._installedFiles.push({ oldFile: aDirectory, newFile: newDir });
   },
   _installDirEntry: function SIO_installDirEntry(aDirEntry, aTargetDirectory, aCopy) {
     let isDir = null;
     try {
       isDir = aDirEntry.isDirectory();
     }
     catch (e) {
       // If the file has already gone away then don't worry about it, this can
       // happen on OSX where the resource fork is automatically moved with the
       // data fork for the file. See bug 733436.
       if (e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
         return;
       logger.error("Failure " + (aCopy ? "copying" : "moving") + " " + aDirEntry.path +
             " to " + aTargetDirectory.path);
       throw e;
     }
     try {
       if (isDir)
         this._installDirectory(aDirEntry, aTargetDirectory, aCopy);
       else
         this._installFile(aDirEntry, aTargetDirectory, aCopy);
     }
     catch (e) {
       logger.error("Failure " + (aCopy ? "copying" : "moving") + " " + aDirEntry.path +
             " to " + aTargetDirectory.path);
       throw e;
     }
   },
   /**
    * Moves a file or directory into a new directory. If an error occurs then all
    * files that have been moved will be moved back to their original location.
    *
    * @param  aFile
    *         The file or directory to be moved.
    * @param  aTargetDirectory
    *         The directory to move into, this is expected to be an empty
    *         directory.
    */
   move: function SIO_move(aFile, aTargetDirectory) {
     try {
       this._installDirEntry(aFile, aTargetDirectory, false);
     }
     catch (e) {
       this.rollback();
       throw e;
     }
   },
   /**
    * Copies a file or directory into a new directory. If an error occurs then
    * all new files that have been created will be removed.
    *
    * @param  aFile
    *         The file or directory to be copied.
    * @param  aTargetDirectory
    *         The directory to copy into, this is expected to be an empty
    *         directory.
    */
   copy: function SIO_copy(aFile, aTargetDirectory) {
     try {
       this._installDirEntry(aFile, aTargetDirectory, true);
     }
     catch (e) {
       this.rollback();
       throw e;
     }
   },
   /**
    * Rolls back all the moves that this operation performed. If an exception
    * occurs here then both old and new directories are left in an indeterminate
    * state
    */
   rollback: function SIO_rollback() {
     while (this._installedFiles.length > 0) {
       let move = this._installedFiles.pop();
       if (move.newFile.isDirectory()) {
         let oldDir = move.oldFile.parent.clone();
         oldDir.append(move.oldFile.leafName);
         oldDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
       }
       else if (!move.oldFile) {
         // No old file means this was a copied file
         move.newFile.remove(true);
       }
       else {
         move.newFile.moveTo(move.oldFile.parent, null);
       }
     }
     while (this._createdDirs.length > 0)
       recursiveRemove(this._createdDirs.pop());
   }
 };
 /**
  * Gets the currently selected locale for display.
  * @return  the selected locale or "en-US" if none is selected
  */
 function getLocale() {
   if (Prefs.getBoolPref(PREF_MATCH_OS_LOCALE, false))
     return Services.locale.getLocaleComponentForUserAgent();
   let locale = Prefs.getComplexValue(PREF_SELECTED_LOCALE, Ci.nsIPrefLocalizedString);
   if (locale)
     return locale;
   return Prefs.getCharPref(PREF_SELECTED_LOCALE, "en-US");
 }
 /**
  * Selects the closest matching locale from a list of locales.
  *
  * @param  aLocales
  *         An array of locales
  * @return the best match for the currently selected locale
  */
 function findClosestLocale(aLocales) {
   let appLocale = getLocale();
   // Holds the best matching localized resource
   var bestmatch = null;
   // The number of locale parts it matched with
   var bestmatchcount = 0;
   // The number of locale parts in the match
   var bestpartcount = 0;
   var matchLocales = [appLocale.toLowerCase()];
   /* If the current locale is English then it will find a match if there is
      a valid match for en-US so no point searching that locale too. */
   if (matchLocales[0].substring(0, 3) != "en-")
     matchLocales.push("en-us");
   for each (var locale in matchLocales) {
     var lparts = locale.split("-");
     for each (var localized in aLocales) {
       for each (let found in localized.locales) {
         found = found.toLowerCase();
         // Exact match is returned immediately
         if (locale == found)
           return localized;
         var fparts = found.split("-");
         /* If we have found a possible match and this one isn't any longer
            then we dont need to check further. */
         if (bestmatch && fparts.length < bestmatchcount)
           continue;
         // Count the number of parts that match
         var maxmatchcount = Math.min(fparts.length, lparts.length);
         var matchcount = 0;
         while (matchcount < maxmatchcount &&
                fparts[matchcount] == lparts[matchcount])
           matchcount++;
         /* If we matched more than the last best match or matched the same and
            this locale is less specific than the last best match. */
         if (matchcount > bestmatchcount ||
            (matchcount == bestmatchcount && fparts.length < bestpartcount)) {
           bestmatch = localized;
           bestmatchcount = matchcount;
           bestpartcount = fparts.length;
         }
       }
     }
     // If we found a valid match for this locale return it
     if (bestmatch)
       return bestmatch;
   }
   return null;
 }
 /**
  * Sets the userDisabled and softDisabled properties of an add-on based on what
  * values those properties had for a previous instance of the add-on. The
  * previous instance may be a previous install or in the case of an application
  * version change the same add-on.
  *
  * NOTE: this may modify aNewAddon in place; callers should save the database if
  * necessary
  *
  * @param  aOldAddon
  *         The previous instance of the add-on
  * @param  aNewAddon
  *         The new instance of the add-on
  * @param  aAppVersion
  *         The optional application version to use when checking the blocklist
  *         or undefined to use the current application
  * @param  aPlatformVersion
  *         The optional platform version to use when checking the blocklist or
  *         undefined to use the current platform
  */
 function applyBlocklistChanges(aOldAddon, aNewAddon, aOldAppVersion,
                                aOldPlatformVersion) {
   // Copy the properties by default
   aNewAddon.userDisabled = aOldAddon.userDisabled;
   aNewAddon.softDisabled = aOldAddon.softDisabled;
   let bs = Cc["@mozilla.org/extensions/blocklist;1"].
            getService(Ci.nsIBlocklistService);
   let oldBlocklistState = bs.getAddonBlocklistState(createWrapper(aOldAddon),
                                                     aOldAppVersion,
                                                     aOldPlatformVersion);
   let newBlocklistState = bs.getAddonBlocklistState(createWrapper(aNewAddon));
   // If the blocklist state hasn't changed then the properties don't need to
   // change
   if (newBlocklistState == oldBlocklistState)
     return;
   if (newBlocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED) {
     if (aNewAddon.type != "theme") {
       // The add-on has become softblocked, set softDisabled if it isn't already
       // userDisabled
       aNewAddon.softDisabled = !aNewAddon.userDisabled;
     }
     else {
       // Themes just get userDisabled to switch back to the default theme
       aNewAddon.userDisabled = true;
     }
   }
   else {
     // If the new add-on is not softblocked then it cannot be softDisabled
     aNewAddon.softDisabled = false;
   }
 }
 /**
  * Calculates whether an add-on should be appDisabled or not.
  *
  * @param  aAddon
  *         The add-on to check
  * @return true if the add-on should not be appDisabled
  */
 function isUsableAddon(aAddon) {
   // Hack to ensure the default theme is always usable
   if (aAddon.type == "theme" && aAddon.internalName == XPIProvider.defaultSkin)
     return true;
   if (aAddon.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED)
     return false;
   if (AddonManager.checkUpdateSecurity && !aAddon.providesUpdatesSecurely)
     return false;
   if (!aAddon.isPlatformCompatible)
     return false;
   if (AddonManager.checkCompatibility) {
     if (!aAddon.isCompatible)
       return false;
   }
   else {
     let app = aAddon.matchingTargetApplication;
     if (!app)
       return false;
     // XXX Temporary solution to let applications opt-in to make themes safer
     //     following significant UI changes even if checkCompatibility=false has
     //     been set, until we get bug 962001.
     if (aAddon.type == "theme" && app.id == Services.appinfo.ID) {
       try {
         let minCompatVersion = Services.prefs.getCharPref(PREF_CHECKCOMAT_THEMEOVERRIDE);
         if (minCompatVersion &&
             Services.vc.compare(minCompatVersion, app.maxVersion) > 0) {
           return false;
         }
       } catch (e) {}
     }
   }
   return true;
 }
 function isAddonDisabled(aAddon) {
   return aAddon.appDisabled || aAddon.softDisabled || aAddon.userDisabled;
 }
 XPCOMUtils.defineLazyServiceGetter(this, "gRDF", "@mozilla.org/rdf/rdf-service;1",
                                    Ci.nsIRDFService);
 function EM_R(aProperty) {
   return gRDF.GetResource(PREFIX_NS_EM + aProperty);
 }
 /**
  * Converts an RDF literal, resource or integer into a string.
  *
  * @param  aLiteral
  *         The RDF object to convert
  * @return a string if the object could be converted or null
  */
 function getRDFValue(aLiteral) {
   if (aLiteral instanceof Ci.nsIRDFLiteral)
     return aLiteral.Value;
   if (aLiteral instanceof Ci.nsIRDFResource)
     return aLiteral.Value;
   if (aLiteral instanceof Ci.nsIRDFInt)
     return aLiteral.Value;
   return null;
 }
 /**
  * Gets an RDF property as a string
  *
  * @param  aDs
  *         The RDF datasource to read the property from
  * @param  aResource
  *         The RDF resource to read the property from
  * @param  aProperty
  *         The property to read
  * @return a string if the property existed or null
  */
 function getRDFProperty(aDs, aResource, aProperty) {
   return getRDFValue(aDs.GetTarget(aResource, EM_R(aProperty), true));
 }
 /**
  * Reads an AddonInternal object from an RDF stream.
  *
  * @param  aUri
  *         The URI that the manifest is being read from
  * @param  aStream
  *         An open stream to read the RDF from
  * @return an AddonInternal object
  * @throws if the install manifest in the RDF stream is corrupt or could not
  *         be read
  */
 function loadManifestFromRDF(aUri, aStream) {
   function getPropertyArray(aDs, aSource, aProperty) {
     let values = [];
     let targets = aDs.GetTargets(aSource, EM_R(aProperty), true);
     while (targets.hasMoreElements())
       values.push(getRDFValue(targets.getNext()));
     return values;
   }
   /**
    * Reads locale properties from either the main install manifest root or
    * an em:localized section in the install manifest.
    *
    * @param  aDs
    *         The nsIRDFDatasource to read from
    * @param  aSource
    *         The nsIRDFResource to read the properties from
    * @param  isDefault
    *         True if the locale is to be read from the main install manifest
    *         root
    * @param  aSeenLocales
    *         An array of locale names already seen for this install manifest.
    *         Any locale names seen as a part of this function will be added to
    *         this array
    * @return an object containing the locale properties
    */
   function readLocale(aDs, aSource, isDefault, aSeenLocales) {
     let locale = { };
     if (!isDefault) {
       locale.locales = [];
       let targets = ds.GetTargets(aSource, EM_R("locale"), true);
       while (targets.hasMoreElements()) {
         let localeName = getRDFValue(targets.getNext());
         if (!localeName) {
           logger.warn("Ignoring empty locale in localized properties");
           continue;
         }
         if (aSeenLocales.indexOf(localeName) != -1) {
           logger.warn("Ignoring duplicate locale in localized properties");
           continue;
         }
         aSeenLocales.push(localeName);
         locale.locales.push(localeName);
       }
       if (locale.locales.length == 0) {
         logger.warn("Ignoring localized properties with no listed locales");
         return null;
       }
     }
     PROP_LOCALE_SINGLE.forEach(function(aProp) {
       locale[aProp] = getRDFProperty(aDs, aSource, aProp);
     });
     PROP_LOCALE_MULTI.forEach(function(aProp) {
       // Don't store empty arrays
       let props = getPropertyArray(aDs, aSource,
                                    aProp.substring(0, aProp.length - 1));
       if (props.length > 0)
         locale[aProp] = props;
     });
     return locale;
   }
   let rdfParser = Cc["@mozilla.org/rdf/xml-parser;1"].
                   createInstance(Ci.nsIRDFXMLParser)
   let ds = Cc["@mozilla.org/rdf/datasource;1?name=in-memory-datasource"].
            createInstance(Ci.nsIRDFDataSource);
   let listener = rdfParser.parseAsync(ds, aUri);
   let channel = Cc["@mozilla.org/network/input-stream-channel;1"].
                 createInstance(Ci.nsIInputStreamChannel);
   channel.setURI(aUri);
   channel.contentStream = aStream;
   channel.QueryInterface(Ci.nsIChannel);
   channel.contentType = "text/xml";
   listener.onStartRequest(channel, null);
   try {
     let pos = 0;
     let count = aStream.available();
     while (count > 0) {
       listener.onDataAvailable(channel, null, aStream, pos, count);
       pos += count;
       count = aStream.available();
     }
     listener.onStopRequest(channel, null, Components.results.NS_OK);
   }
   catch (e) {
     listener.onStopRequest(channel, null, e.result);
     throw e;
   }
   let root = gRDF.GetResource(RDFURI_INSTALL_MANIFEST_ROOT);
   let addon = new AddonInternal();
   PROP_METADATA.forEach(function(aProp) {
     addon[aProp] = getRDFProperty(ds, root, aProp);
   });
   addon.unpack = getRDFProperty(ds, root, "unpack") == "true";
   if (!addon.type) {
     addon.type = addon.internalName ? "theme" : "extension";
   }
   else {
     let type = addon.type;
     addon.type = null;
     for (let name in TYPES) {
       if (TYPES[name] == type) {
         addon.type = name;
         break;
       }
     }
   }
   if (!(addon.type in TYPES))
     throw new Error("Install manifest specifies unknown type: " + addon.type);
   if (addon.type != "multipackage") {
     if (!addon.id)
       throw new Error("No ID in install manifest");
     if (!gIDTest.test(addon.id))
       throw new Error("Illegal add-on ID " + addon.id);
     if (!addon.version)
       throw new Error("No version in install manifest");
   }
   addon.strictCompatibility = !(addon.type in COMPATIBLE_BY_DEFAULT_TYPES) ||
                               getRDFProperty(ds, root, "strictCompatibility") == "true";
   // Only read the bootstrap property for extensions.
   if (addon.type == "extension") {
     addon.bootstrap = getRDFProperty(ds, root, "bootstrap") == "true";
     if (addon.optionsType &&
         addon.optionsType != AddonManager.OPTIONS_TYPE_DIALOG &&
         addon.optionsType != AddonManager.OPTIONS_TYPE_INLINE &&
         addon.optionsType != AddonManager.OPTIONS_TYPE_TAB &&
         addon.optionsType != AddonManager.OPTIONS_TYPE_INLINE_INFO) {
       throw new Error("Install manifest specifies unknown type: " + addon.optionsType);
     }
   }
   else {
     // Some add-on types are always restartless.
     if (RESTARTLESS_TYPES.has(addon.type)) {
       addon.bootstrap = true;
     }
     // Only extensions are allowed to provide an optionsURL, optionsType or aboutURL. For
     // all other types they are silently ignored
     addon.optionsURL = null;
     addon.optionsType = null;
     addon.aboutURL = null;
     if (addon.type == "theme") {
       if (!addon.internalName)
         throw new Error("Themes must include an internalName property");
       addon.skinnable = getRDFProperty(ds, root, "skinnable") == "true";
     }
   }
   addon.defaultLocale = readLocale(ds, root, true);
   let seenLocales = [];
   addon.locales = [];
   let targets = ds.GetTargets(root, EM_R("localized"), true);
   while (targets.hasMoreElements()) {
     let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
     let locale = readLocale(ds, target, false, seenLocales);
     if (locale)
       addon.locales.push(locale);
   }
   let seenApplications = [];
   addon.targetApplications = [];
   targets = ds.GetTargets(root, EM_R("targetApplication"), true);
   while (targets.hasMoreElements()) {
     let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
     let targetAppInfo = {};
     PROP_TARGETAPP.forEach(function(aProp) {
       targetAppInfo[aProp] = getRDFProperty(ds, target, aProp);
     });
     if (!targetAppInfo.id || !targetAppInfo.minVersion ||
         !targetAppInfo.maxVersion) {
       logger.warn("Ignoring invalid targetApplication entry in install manifest");
       continue;
     }
     if (seenApplications.indexOf(targetAppInfo.id) != -1) {
       logger.warn("Ignoring duplicate targetApplication entry for " + targetAppInfo.id +
            " in install manifest");
       continue;
     }
     seenApplications.push(targetAppInfo.id);
     addon.targetApplications.push(targetAppInfo);
   }
   // Note that we don't need to check for duplicate targetPlatform entries since
   // the RDF service coalesces them for us.
   let targetPlatforms = getPropertyArray(ds, root, "targetPlatform");
   addon.targetPlatforms = [];
   targetPlatforms.forEach(function(aPlatform) {
     let platform = {
       os: null,
       abi: null
     };
     let pos = aPlatform.indexOf("_");
     if (pos != -1) {
       platform.os = aPlatform.substring(0, pos);
       platform.abi = aPlatform.substring(pos + 1);
     }
     else {
       platform.os = aPlatform;
     }
     addon.targetPlatforms.push(platform);
   });
   // A theme's userDisabled value is true if the theme is not the selected skin
   // or if there is an active lightweight theme. We ignore whether softblocking
   // is in effect since it would change the active theme.
   if (addon.type == "theme") {
     addon.userDisabled = !!LightweightThemeManager.currentTheme ||
                          addon.internalName != XPIProvider.selectedSkin;
   }
   // Experiments are disabled by default. It is up to the Experiments Manager
   // to enable them (it drives installation).
   else if (addon.type == "experiment") {
     addon.userDisabled = true;
   }
   else {
     addon.userDisabled = false;
     addon.softDisabled = addon.blocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED;
   }
   addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT;
   // Experiments are managed and updated through an external "experiments
   // manager." So disable some built-in mechanisms.
   if (addon.type == "experiment") {
     addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;
     addon.updateURL = null;
     addon.updateKey = null;
     addon.targetApplications = [];
     addon.targetPlatforms = [];
   }
   // Load the storage service before NSS (nsIRandomGenerator),
   // to avoid a SQLite initialization error (bug 717904).
   let storage = Services.storage;
   // Generate random GUID used for Sync.
   // This was lifted from util.js:makeGUID() from services-sync.
   let rng = Cc["@mozilla.org/security/random-generator;1"].
             createInstance(Ci.nsIRandomGenerator);
   let bytes = rng.generateRandomBytes(9);
   let byte_string = [String.fromCharCode(byte) for each (byte in bytes)]
                     .join("");
   // Base64 encode
   addon.syncGUID = btoa(byte_string).replace(/\+/g, '-')
                                     .replace(/\//g, '_');
   return addon;
 }
 /**
  * Loads an AddonInternal object from an add-on extracted in a directory.
  *
  * @param  aDir
  *         The nsIFile directory holding the add-on
  * @return an AddonInternal object
  * @throws if the directory does not contain a valid install manifest
  */
 function loadManifestFromDir(aDir) {
   function getFileSize(aFile) {
     if (aFile.isSymlink())
       return 0;
     if (!aFile.isDirectory())
       return aFile.fileSize;
     let size = 0;
     let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
     let entry;
     while ((entry = entries.nextFile))
       size += getFileSize(entry);
     entries.close();
     return size;
   }
   let file = aDir.clone();
   file.append(FILE_INSTALL_MANIFEST);
   if (!file.exists() || !file.isFile())
     throw new Error("Directory " + aDir.path + " does not contain a valid " +
                     "install manifest");
   let fis = Cc["@mozilla.org/network/file-input-stream;1"].
             createInstance(Ci.nsIFileInputStream);
   fis.init(file, -1, -1, false);
   let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
             createInstance(Ci.nsIBufferedInputStream);
   bis.init(fis, 4096);
   try {
     let addon = loadManifestFromRDF(Services.io.newFileURI(file), bis);
     addon._sourceBundle = aDir.clone();
     addon.size = getFileSize(aDir);
     file = aDir.clone();
     file.append("chrome.manifest");
     let chromeManifest = ChromeManifestParser.parseSync(Services.io.newFileURI(file));
     addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
                                                              "binary-component");
     addon.appDisabled = !isUsableAddon(addon);
     return addon;
   }
   finally {
     bis.close();
     fis.close();
   }
 }
 /**
  * Loads an AddonInternal object from an nsIZipReader for an add-on.
  *
  * @param  aZipReader
  *         An open nsIZipReader for the add-on's files
  * @return an AddonInternal object
  * @throws if the XPI file does not contain a valid install manifest
  */
 function loadManifestFromZipReader(aZipReader) {
   let zis = aZipReader.getInputStream(FILE_INSTALL_MANIFEST);
   let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
             createInstance(Ci.nsIBufferedInputStream);
   bis.init(zis, 4096);
   try {
     let uri = buildJarURI(aZipReader.file, FILE_INSTALL_MANIFEST);
     let addon = loadManifestFromRDF(uri, bis);
     addon._sourceBundle = aZipReader.file;
     addon.size = 0;
     let entries = aZipReader.findEntries(null);
     while (entries.hasMore())
       addon.size += aZipReader.getEntry(entries.getNext()).realSize;
     // Binary components can only be loaded from unpacked addons.
     if (addon.unpack) {
       uri = buildJarURI(aZipReader.file, "chrome.manifest");
       let chromeManifest = ChromeManifestParser.parseSync(uri);
       addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
                                                                "binary-component");
     } else {
       addon.hasBinaryComponents = false;
     }
     addon.appDisabled = !isUsableAddon(addon);
     return addon;
   }
   finally {
     bis.close();
     zis.close();
   }
 }
 /**
  * Loads an AddonInternal object from an add-on in an XPI file.
  *
  * @param  aXPIFile
  *         An nsIFile pointing to the add-on's XPI file
  * @return an AddonInternal object
  * @throws if the XPI file does not contain a valid install manifest
  */
 function loadManifestFromZipFile(aXPIFile) {
   let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
                   createInstance(Ci.nsIZipReader);
   try {
     zipReader.open(aXPIFile);
     return loadManifestFromZipReader(zipReader);
   }
   finally {
     zipReader.close();
   }
 }
 function loadManifestFromFile(aFile) {
   if (aFile.isFile())
     return loadManifestFromZipFile(aFile);
   else
     return loadManifestFromDir(aFile);
 }
 /**
  * Gets an nsIURI for a file within another file, either a directory or an XPI
  * file. If aFile is a directory then this will return a file: URI, if it is an
  * XPI file then it will return a jar: URI.
  *
  * @param  aFile
  *         The file containing the resources, must be either a directory or an
  *         XPI file
  * @param  aPath
  *         The path to find the resource at, "/" separated. If aPath is empty
  *         then the uri to the root of the contained files will be returned
  * @return an nsIURI pointing at the resource
  */
 function getURIForResourceInFile(aFile, aPath) {
   if (aFile.isDirectory()) {
     let resource = aFile.clone();
     if (aPath) {
       aPath.split("/").forEach(function(aPart) {
         resource.append(aPart);
       });
     }
     return NetUtil.newURI(resource);
   }
   return buildJarURI(aFile, aPath);
 }
 /**
  * Creates a jar: URI for a file inside a ZIP file.
  *
  * @param  aJarfile
  *         The ZIP file as an nsIFile
  * @param  aPath
  *         The path inside the ZIP file
  * @return an nsIURI for the file
  */
 function buildJarURI(aJarfile, aPath) {
   let uri = Services.io.newFileURI(aJarfile);
   uri = "jar:" + uri.spec + "!/" + aPath;
   return NetUtil.newURI(uri);
 }
 /**
  * Sends local and remote notifications to flush a JAR file cache entry
  *
  * @param aJarFile
  *        The ZIP/XPI/JAR file as a nsIFile
  */
 function flushJarCache(aJarFile) {
   Services.obs.notifyObservers(aJarFile, "flush-cache-entry", null);
   Cc["@mozilla.org/globalmessagemanager;1"].getService(Ci.nsIMessageBroadcaster)
     .broadcastAsyncMessage(MSG_JAR_FLUSH, aJarFile.path);
 }
 function flushStartupCache() {
   // Init this, so it will get the notification.
   Services.obs.notifyObservers(null, "startupcache-invalidate", null);
 }
 /**
  * Creates and returns a new unique temporary file. The caller should delete
  * the file when it is no longer needed.
  *
  * @return an nsIFile that points to a randomly named, initially empty file in
  *         the OS temporary files directory
  */
 function getTemporaryFile() {
   let file = FileUtils.getDir(KEY_TEMPDIR, []);
   let random = Math.random().toString(36).replace(/0./, '').substr(-3);
   file.append("tmp-" + random + ".xpi");
   file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
   return file;
 }
 /**
  * Verifies that a zip file's contents are all signed by the same principal.
  * Directory entries and anything in the META-INF directory are not checked.
  *
  * @param  aZip
  *         A nsIZipReader to check
  * @param  aPrincipal
  *         The nsIPrincipal to compare against
  * @return true if all the contents that should be signed were signed by the
  *         principal
  */
 function verifyZipSigning(aZip, aPrincipal) {
   var count = 0;
   var entries = aZip.findEntries(null);
   while (entries.hasMore()) {
     var entry = entries.getNext();
     // Nothing in META-INF is in the manifest.
     if (entry.substr(0, 9) == "META-INF/")
       continue;
     // Directory entries aren't in the manifest.
     if (entry.substr(-1) == "/")
       continue;
     count++;
     var entryPrincipal = aZip.getCertificatePrincipal(entry);
     if (!entryPrincipal || !aPrincipal.equals(entryPrincipal))
       return false;
   }
   return aZip.manifestEntriesCount == count;
 }
 /**
  * Replaces %...% strings in an addon url (update and updateInfo) with
  * appropriate values.
  *
  * @param  aAddon
  *         The AddonInternal representing the add-on
  * @param  aUri
  *         The uri to escape
  * @param  aUpdateType
  *         An optional number representing the type of update, only applicable
  *         when creating a url for retrieving an update manifest
  * @param  aAppVersion
  *         The optional application version to use for %APP_VERSION%
  * @return the appropriately escaped uri.
  */
 function escapeAddonURI(aAddon, aUri, aUpdateType, aAppVersion)
 {
   let uri = AddonManager.escapeAddonURI(aAddon, aUri, aAppVersion);
   // If there is an updateType then replace the UPDATE_TYPE string
   if (aUpdateType)
     uri = uri.replace(/%UPDATE_TYPE%/g, aUpdateType);
   // If this add-on has compatibility information for either the current
   // application or toolkit then replace the ITEM_MAXAPPVERSION with the
   // maxVersion
   let app = aAddon.matchingTargetApplication;
   if (app)
     var maxVersion = app.maxVersion;
   else
     maxVersion = "";
   uri = uri.replace(/%ITEM_MAXAPPVERSION%/g, maxVersion);
   let compatMode = "normal";
   if (!AddonManager.checkCompatibility)
     compatMode = "ignore";
   else if (AddonManager.strictCompatibility)
     compatMode = "strict";
   uri = uri.replace(/%COMPATIBILITY_MODE%/g, compatMode);
   return uri;
 }
 function removeAsync(aFile) {
   return Task.spawn(function () {
     let info = null;
     try {
       info = yield OS.File.stat(aFile.path);
       if (info.isDir)
         yield OS.File.removeDir(aFile.path);
       else
         yield OS.File.remove(aFile.path);
     }
     catch (e if e instanceof OS.File.Error && e.becauseNoSuchFile) {
       // The file has already gone away
       return;
     }
   });
 }
 /**
  * Recursively removes a directory or file fixing permissions when necessary.
  *
  * @param  aFile
  *         The nsIFile to remove
  */
 function recursiveRemove(aFile) {
   let isDir = null;
   try {
     isDir = aFile.isDirectory();
   }
   catch (e) {
     // If the file has already gone away then don't worry about it, this can
     // happen on OSX where the resource fork is automatically moved with the
     // data fork for the file. See bug 733436.
     if (e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
       return;
     if (e.result == Cr.NS_ERROR_FILE_NOT_FOUND)
       return;
     throw e;
   }
   setFilePermissions(aFile, isDir ? FileUtils.PERMS_DIRECTORY
                                   : FileUtils.PERMS_FILE);
   try {
     aFile.remove(true);
     return;
   }
   catch (e) {
     if (!aFile.isDirectory()) {
       logger.error("Failed to remove file " + aFile.path, e);
       throw e;
     }
   }
   // Use a snapshot of the directory contents to avoid possible issues with
   // iterating over a directory while removing files from it (the YAFFS2
   // embedded filesystem has this issue, see bug 772238), and to remove
   // normal files before their resource forks on OSX (see bug 733436).
   let entries = getDirectoryEntries(aFile, true);
   entries.forEach(recursiveRemove);
   try {
     aFile.remove(true);
   }
   catch (e) {
     logger.error("Failed to remove empty directory " + aFile.path, e);
     throw e;
   }
 }
 /**
  * Returns the timestamp and leaf file name of the most recently modified
  * entry in a directory,
  * or simply the file's own timestamp if it is not a directory.
  * Also returns the total number of items (directories and files) visited in the scan
  *
  * @param  aFile
  *         A non-null nsIFile object
  * @return [File Name, Epoch time, items visited], as described above.
  */
 function recursiveLastModifiedTime(aFile) {
   try {
     let modTime = aFile.lastModifiedTime;
     let fileName = aFile.leafName;
     if (aFile.isFile())
       return [fileName, modTime, 1];
     if (aFile.isDirectory()) {
       let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
       let entry;
       let totalItems = 1;
       while ((entry = entries.nextFile)) {
         let [subName, subTime, items] = recursiveLastModifiedTime(entry);
         totalItems += items;
         if (subTime > modTime) {
           modTime = subTime;
           fileName = subName;
         }
       }
       entries.close();
       return [fileName, modTime, totalItems];
     }
   }
   catch (e) {
     logger.warn("Problem getting last modified time for " + aFile.path, e);
   }
   // If the file is something else, just ignore it.
   return ["", 0, 0];
 }
 /**
  * Gets a snapshot of directory entries.
  *
  * @param  aDir
  *         Directory to look at
  * @param  aSortEntries
  *         True to sort entries by filename
  * @return An array of nsIFile, or an empty array if aDir is not a readable directory
  */
 function getDirectoryEntries(aDir, aSortEntries) {
   let dirEnum;
   try {
     dirEnum = aDir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
     let entries = [];
     while (dirEnum.hasMoreElements())
       entries.push(dirEnum.nextFile);
     if (aSortEntries) {
       entries.sort(function sortDirEntries(a, b) {
         return a.path > b.path ? -1 : 1;
       });
     }
     return entries
   }
   catch (e) {
     logger.warn("Can't iterate directory " + aDir.path, e);
     return [];
   }
   finally {
     if (dirEnum) {
       dirEnum.close();
     }
   }
 }
 /**
  * A helpful wrapper around the prefs service that allows for default values
  * when requested values aren't set.
  */
 var Prefs = {
   /**
    * Gets a preference from the default branch ignoring user-set values.
    *
    * @param  aName
    *         The name of the preference
    * @param  aDefaultValue
    *         A value to return if the preference does not exist
    * @return the default value of the preference or aDefaultValue if there is
    *         none
    */
   getDefaultCharPref: function Prefs_getDefaultCharPref(aName, aDefaultValue) {
     try {
       return Services.prefs.getDefaultBranch("").getCharPref(aName);
     }
     catch (e) {
     }
     return aDefaultValue;
   },
   /**
    * Gets a string preference.
    *
    * @param  aName
    *         The name of the preference
    * @param  aDefaultValue
    *         A value to return if the preference does not exist
    * @return the value of the preference or aDefaultValue if there is none
    */
   getCharPref: function Prefs_getCharPref(aName, aDefaultValue) {
     try {
       return Services.prefs.getCharPref(aName);
     }
     catch (e) {
     }
     return aDefaultValue;
   },
   /**
    * Gets a complex preference.
    *
    * @param  aName
    *         The name of the preference
    * @param  aType
    *         The interface type of the preference
    * @param  aDefaultValue
    *         A value to return if the preference does not exist
    * @return the value of the preference or aDefaultValue if there is none
    */
   getComplexValue: function Prefs_getComplexValue(aName, aType, aDefaultValue) {
     try {
       return Services.prefs.getComplexValue(aName, aType).data;
     }
     catch (e) {
     }
     return aDefaultValue;
   },
   /**
    * Gets a boolean preference.
    *
    * @param  aName
    *         The name of the preference
    * @param  aDefaultValue
    *         A value to return if the preference does not exist
    * @return the value of the preference or aDefaultValue if there is none
    */
   getBoolPref: function Prefs_getBoolPref(aName, aDefaultValue) {
     try {
       return Services.prefs.getBoolPref(aName);
     }
     catch (e) {
     }
     return aDefaultValue;
   },
   /**
    * Gets an integer preference.
    *
    * @param  aName
    *         The name of the preference
    * @param  defaultValue
    *         A value to return if the preference does not exist
    * @return the value of the preference or defaultValue if there is none
    */
   getIntPref: function Prefs_getIntPref(aName, defaultValue) {
     try {
       return Services.prefs.getIntPref(aName);
     }
     catch (e) {
     }
     return defaultValue;
   },
   /**
    * Clears a preference if it has a user value
    *
    * @param  aName
    *         The name of the preference
    */
   clearUserPref: function Prefs_clearUserPref(aName) {
     if (Services.prefs.prefHasUserValue(aName))
       Services.prefs.clearUserPref(aName);
   }
 }
 // Helper function to compare JSON saved version of the directory state
 // with the new state returned by getInstallLocationStates()
 // Structure is: ordered array of {'name':?, 'addons': {addonID: {'descriptor':?, 'mtime':?} ...}}
 function directoryStateDiffers(aState, aCache)
 {
   // check equality of an object full of addons; fortunately we can destroy the 'aOld' object
   function addonsMismatch(aNew, aOld) {
     for (let [id, val] of aNew) {
       if (!id in aOld)
         return true;
       if (val.descriptor != aOld[id].descriptor ||
           val.mtime != aOld[id].mtime)
         return true;
       delete aOld[id];
     }
     // make sure aOld doesn't have any extra entries
     for (let id in aOld)
       return true;
     return false;
   }
   if (!aCache)
     return true;
   try {
     let old = JSON.parse(aCache);
     if (aState.length != old.length)
       return true;
     for (let i = 0; i < aState.length; i++) {
       // conveniently, any missing fields would require a 'true' return, which is
       // handled by our catch wrapper
       if (aState[i].name != old[i].name)
         return true;
       if (addonsMismatch(aState[i].addons, old[i].addons))
         return true;
     }
   }
   catch (e) {
     return true;
   }
   return false;
 }
 /**
  * Wraps a function in an exception handler to protect against exceptions inside callbacks
  * @param aFunction function(args...)
  * @return function(args...), a function that takes the same arguments as aFunction
  *         and returns the same result unless aFunction throws, in which case it logs
  *         a warning and returns undefined.
  */
 function makeSafe(aFunction) {
   return function(...aArgs) {
     try {
       return aFunction(...aArgs);
     }
     catch(ex) {
       logger.warn("XPIProvider callback failed", ex);
     }
     return undefined;
   }
 }
 this.XPIProvider = {
   // An array of known install locations
   installLocations: null,
   // A dictionary of known install locations by name
   installLocationsByName: null,
   // An array of currently active AddonInstalls
   installs: null,
   // The default skin for the application
   defaultSkin: "classic/1.0",
   // The current skin used by the application
   currentSkin: null,
   // The selected skin to be used by the application when it is restarted. This
   // will be the same as currentSkin when it is the skin to be used when the
   // application is restarted
   selectedSkin: null,
   // The value of the minCompatibleAppVersion preference
   minCompatibleAppVersion: null,
   // The value of the minCompatiblePlatformVersion preference
   minCompatiblePlatformVersion: null,
   // A dictionary of the file descriptors for bootstrappable add-ons by ID
   bootstrappedAddons: {},
   // A dictionary of JS scopes of loaded bootstrappable add-ons by ID
   bootstrapScopes: {},
   // True if the platform could have activated extensions
   extensionsActive: false,
   // File / directory state of installed add-ons
   installStates: [],
   // True if all of the add-ons found during startup were installed in the
   // application install location
   allAppGlobal: true,
   // A string listing the enabled add-ons for annotating crash reports
   enabledAddons: null,
   // An array of add-on IDs of add-ons that were inactive during startup
   inactiveAddonIDs: [],
   // Keep track of startup phases for telemetry
   runPhase: XPI_STARTING,
   // Keep track of the newest file in each add-on, in case we want to
   // report it to telemetry.
   _mostRecentlyModifiedFile: {},
   // Per-addon telemetry information
   _telemetryDetails: {},
   // Experiments are disabled by default. Track ones that are locally enabled.
   _enabledExperiments: null,
   /*
    * Set a value in the telemetry hash for a given ID
    */
   setTelemetry: function XPI_setTelemetry(aId, aName, aValue) {
     if (!this._telemetryDetails[aId])
       this._telemetryDetails[aId] = {};
     this._telemetryDetails[aId][aName] = aValue;
   },
   // Keep track of in-progress operations that support cancel()
   _inProgress: new Set(),
   doing: function XPI_doing(aCancellable) {
     this._inProgress.add(aCancellable);
   },
   done: function XPI_done(aCancellable) {
     return this._inProgress.delete(aCancellable);
   },
   cancelAll: function XPI_cancelAll() {
     // Cancelling one may alter _inProgress, so restart the iterator after each
     while (this._inProgress.size > 0) {
       for (let c of this._inProgress) {
         try {
           c.cancel();
         }
         catch (e) {
           logger.warn("Cancel failed", e);
         }
         this._inProgress.delete(c);
       }
     }
   },
   /**
    * Adds or updates a URI mapping for an Addon.id.
    *
    * Mappings should not be removed at any point. This is so that the mappings
    * will be still valid after an add-on gets disabled or uninstalled, as
    * consumers may still have URIs of (leaked) resources they want to map.
    */
   _addURIMapping: function XPI__addURIMapping(aID, aFile) {
     try {
       // Always use our own mechanics instead of nsIIOService.newFileURI, so
       // that we can be sure to map things as we want them mapped.
       let uri = this._resolveURIToFile(getURIForResourceInFile(aFile, "."));
       if (!uri) {
         throw new Error("Cannot resolve");
       }
       this._ensureURIMappings();
       this._uriMappings[aID] = uri.spec;
     }
     catch (ex) {
       logger.warn("Failed to add URI mapping", ex);
     }
   },
   /**
    * Ensures that the URI to Addon mappings are available.
    *
    * The function will add mappings for all non-bootstrapped but enabled
    * add-ons.
    * Bootstrapped add-on mappings will be added directly when the bootstrap
    * scope get loaded. (See XPIProvider._addURIMapping() and callers)
    */
   _ensureURIMappings: function XPI__ensureURIMappings() {
     if (this._uriMappings) {
       return;
     }
     // XXX Convert to Map(), once it gets stable with stable iterators
     this._uriMappings = Object.create(null);
     // XXX Convert to Set(), once it gets stable with stable iterators
     let enabled = Object.create(null);
     let enabledAddons = this.enabledAddons || "";
     for (let a of enabledAddons.split(",")) {
       a = decodeURIComponent(a.split(":")[0]);
       enabled[a] = null;
     }
     let cache = JSON.parse(Prefs.getCharPref(PREF_INSTALL_CACHE, "[]"));
     for (let loc of cache) {
       for (let [id, val] in Iterator(loc.addons)) {
         if (!(id in enabled)) {
           continue;
         }
         let file = new nsIFile(val.descriptor);
         let spec = Services.io.newFileURI(file).spec;
         this._uriMappings[id] = spec;
       }
     }
   },
   /**
    * Resolve a URI back to physical file.
    *
    * Of course, this works only for URIs pointing to local resources.
    *
    * @param  aURI
    *         URI to resolve
    * @return
    *         resolved nsIFileURL
    */
   _resolveURIToFile: function XPI__resolveURIToFile(aURI) {
     switch (aURI.scheme) {
       case "jar":
       case "file":
         if (aURI instanceof Ci.nsIJARURI) {
           return this._resolveURIToFile(aURI.JARFile);
         }
         return aURI;
       case "chrome":
         aURI = ChromeRegistry.convertChromeURL(aURI);
         return this._resolveURIToFile(aURI);
       case "resource":
         aURI = Services.io.newURI(ResProtocolHandler.resolveURI(aURI), null,
                                   null);
         return this._resolveURIToFile(aURI);
       case "view-source":
         aURI = Services.io.newURI(aURI.path, null, null);
         return this._resolveURIToFile(aURI);
       case "about":
         if (aURI.spec == "about:blank") {
           // Do not attempt to map about:blank
           return null;
         }
         let chan;
         try {
           chan = Services.io.newChannelFromURI(aURI);
         }
         catch (ex) {
           return null;
         }
         // Avoid looping
         if (chan.URI.equals(aURI)) {
           return null;
         }
         // We want to clone the channel URI to avoid accidentially keeping
         // unnecessary references to the channel or implementation details
         // around.
         return this._resolveURIToFile(chan.URI.clone());
       default:
         return null;
     }
   },
   /**
    * Starts the XPI provider initializes the install locations and prefs.
    *
    * @param  aAppChanged
    *         A tri-state value. Undefined means the current profile was created
    *         for this session, true means the profile already existed but was
    *         last used with an application with a different version number,
    *         false means that the profile was last used by this version of the
    *         application.
    * @param  aOldAppVersion
    *         The version of the application last run with this profile or null
    *         if it is a new profile or the version is unknown
    * @param  aOldPlatformVersion
    *         The version of the platform last run with this profile or null
    *         if it is a new profile or the version is unknown
    */
   startup: function XPI_startup(aAppChanged, aOldAppVersion, aOldPlatformVersion) {
     function addDirectoryInstallLocation(aName, aKey, aPaths, aScope, aLocked) {
       try {
         var dir = FileUtils.getDir(aKey, aPaths);
       }
       catch (e) {
         // Some directories aren't defined on some platforms, ignore them
         logger.debug("Skipping unavailable install location " + aName);
         return;
       }
       try {
         var location = new DirectoryInstallLocation(aName, dir, aScope, aLocked);
       }
       catch (e) {
         logger.warn("Failed to add directory install location " + aName, e);
         return;
       }
       XPIProvider.installLocations.push(location);
       XPIProvider.installLocationsByName[location.name] = location;
     }
     function addRegistryInstallLocation(aName, aRootkey, aScope) {
       try {
         var location = new WinRegInstallLocation(aName, aRootkey, aScope);
       }
       catch (e) {
         logger.warn("Failed to add registry install location " + aName, e);
         return;
       }
       XPIProvider.installLocations.push(location);
       XPIProvider.installLocationsByName[location.name] = location;
     }
     try {
       AddonManagerPrivate.recordTimestamp("XPI_startup_begin");
       logger.debug("startup");
       this.runPhase = XPI_STARTING;
       this.installs = [];
       this.installLocations = [];
       this.installLocationsByName = {};
       // Hook for tests to detect when saving database at shutdown time fails
       this._shutdownError = null;
       // Clear this at startup for xpcshell test restarts
       this._telemetryDetails = {};
       // Clear the set of enabled experiments (experiments disabled by default).
       this._enabledExperiments = new Set();
       // Register our details structure with AddonManager
       AddonManagerPrivate.setTelemetryDetails("XPI", this._telemetryDetails);
       let hasRegistry = ("nsIWindowsRegKey" in Ci);
       let enabledScopes = Prefs.getIntPref(PREF_EM_ENABLED_SCOPES,
                                            AddonManager.SCOPE_ALL);
       // These must be in order of priority for processFileChanges etc. to work
       if (enabledScopes & AddonManager.SCOPE_SYSTEM) {
         if (hasRegistry) {
           addRegistryInstallLocation("winreg-app-global",
                                      Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE,
                                      AddonManager.SCOPE_SYSTEM);
         }
         addDirectoryInstallLocation(KEY_APP_SYSTEM_LOCAL, "XRESysLExtPD",
                                     [Services.appinfo.ID],
                                     AddonManager.SCOPE_SYSTEM, true);
         addDirectoryInstallLocation(KEY_APP_SYSTEM_SHARE, "XRESysSExtPD",
                                     [Services.appinfo.ID],
                                     AddonManager.SCOPE_SYSTEM, true);
       }
       if (enabledScopes & AddonManager.SCOPE_APPLICATION) {
         addDirectoryInstallLocation(KEY_APP_GLOBAL, KEY_APPDIR,
                                     [DIR_EXTENSIONS],
                                     AddonManager.SCOPE_APPLICATION, true);
       }
       if (enabledScopes & AddonManager.SCOPE_USER) {
         if (hasRegistry) {
           addRegistryInstallLocation("winreg-app-user",
                                      Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
                                      AddonManager.SCOPE_USER);
         }
         addDirectoryInstallLocation(KEY_APP_SYSTEM_USER, "XREUSysExt",
                                     [Services.appinfo.ID],
                                     AddonManager.SCOPE_USER, true);
       }
       // The profile location is always enabled
       addDirectoryInstallLocation(KEY_APP_PROFILE, KEY_PROFILEDIR,
                                   [DIR_EXTENSIONS],
                                   AddonManager.SCOPE_PROFILE, false);
       this.defaultSkin = Prefs.getDefaultCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
                                                   "classic/1.0");
       this.currentSkin = Prefs.getCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
                                            this.defaultSkin);
       this.selectedSkin = this.currentSkin;
       this.applyThemeChange();
       this.minCompatibleAppVersion = Prefs.getCharPref(PREF_EM_MIN_COMPAT_APP_VERSION,
                                                        null);
       this.minCompatiblePlatformVersion = Prefs.getCharPref(PREF_EM_MIN_COMPAT_PLATFORM_VERSION,
                                                             null);
       this.enabledAddons = "";
       Services.prefs.addObserver(PREF_EM_MIN_COMPAT_APP_VERSION, this, false);
       Services.prefs.addObserver(PREF_EM_MIN_COMPAT_PLATFORM_VERSION, this, false);
       Services.obs.addObserver(this, NOTIFICATION_FLUSH_PERMISSIONS, false);
       try {
         BrowserToolboxProcess.on("connectionchange",
                                  this.onDebugConnectionChange.bind(this));
       }
       catch (e) {
         // BrowserToolboxProcess is not available in all applications
       }
       let flushCaches = this.checkForChanges(aAppChanged, aOldAppVersion,
                                              aOldPlatformVersion);
       // Changes to installed extensions may have changed which theme is selected
       this.applyThemeChange();
       // If the application has been upgraded and there are add-ons outside the
       // application directory then we may need to synchronize compatibility
       // information but only if the mismatch UI isn't disabled
       if (aAppChanged && !this.allAppGlobal &&
           Prefs.getBoolPref(PREF_EM_SHOW_MISMATCH_UI, true)) {
         this.showUpgradeUI();
         flushCaches = true;
       }
       else if (aAppChanged === undefined) {
         // For new profiles we will never need to show the add-on selection UI
         Services.prefs.setBoolPref(PREF_SHOWN_SELECTION_UI, true);
       }
       if (flushCaches) {
         flushStartupCache();
         // UI displayed early in startup (like the compatibility UI) may have
         // caused us to cache parts of the skin or locale in memory. These must
         // be flushed to allow extension provided skins and locales to take full
         // effect
         Services.obs.notifyObservers(null, "chrome-flush-skin-caches", null);
         Services.obs.notifyObservers(null, "chrome-flush-caches", null);
       }
       this.enabledAddons = Prefs.getCharPref(PREF_EM_ENABLED_ADDONS, "");
       // Invalidate the URI mappings now that |enabledAddons| was updated.
       // |_ensureMappings()| will re-create the mappings when needed.
       delete this._uriMappings;
       if ("nsICrashReporter" in Ci &&
           Services.appinfo instanceof Ci.nsICrashReporter) {
         // Annotate the crash report with relevant add-on information.
         try {
           Services.appinfo.annotateCrashReport("Theme", this.currentSkin);
         } catch (e) { }
         try {
           Services.appinfo.annotateCrashReport("EMCheckCompatibility",
                                                AddonManager.checkCompatibility);
         } catch (e) { }
         this.addAddonsToCrashReporter();
       }
       try {
         AddonManagerPrivate.recordTimestamp("XPI_bootstrap_addons_begin");
         for (let id in this.bootstrappedAddons) {
           try {
             let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
             file.persistentDescriptor = this.bootstrappedAddons[id].descriptor;
             let reason = BOOTSTRAP_REASONS.APP_STARTUP;
             // Eventually set INSTALLED reason when a bootstrap addon
             // is dropped in profile folder and automatically installed
             if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
                             .indexOf(id) !== -1)
               reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
             this.callBootstrapMethod(id, this.bootstrappedAddons[id].version,
                                      this.bootstrappedAddons[id].type, file,
                                      "startup", reason);
           }
           catch (e) {
             logger.error("Failed to load bootstrap addon " + id + " from " +
                   this.bootstrappedAddons[id].descriptor, e);
           }
         }
         AddonManagerPrivate.recordTimestamp("XPI_bootstrap_addons_end");
       }
       catch (e) {
         logger.error("bootstrap startup failed", e);
         AddonManagerPrivate.recordException("XPI-BOOTSTRAP", "startup failed", e);
       }
       // Let these shutdown a little earlier when they still have access to most
       // of XPCOM
       Services.obs.addObserver({
         observe: function shutdownObserver(aSubject, aTopic, aData) {
           for (let id in XPIProvider.bootstrappedAddons) {
             let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
             file.persistentDescriptor = XPIProvider.bootstrappedAddons[id].descriptor;
             XPIProvider.callBootstrapMethod(id, XPIProvider.bootstrappedAddons[id].version,
                                             XPIProvider.bootstrappedAddons[id].type, file, "shutdown",
                                             BOOTSTRAP_REASONS.APP_SHUTDOWN);
           }
           Services.obs.removeObserver(this, "quit-application-granted");
         }
       }, "quit-application-granted", false);
       // Detect final-ui-startup for telemetry reporting
       Services.obs.addObserver({
         observe: function uiStartupObserver(aSubject, aTopic, aData) {
           AddonManagerPrivate.recordTimestamp("XPI_finalUIStartup");
           XPIProvider.runPhase = XPI_AFTER_UI_STARTUP;
           Services.obs.removeObserver(this, "final-ui-startup");
         }
       }, "final-ui-startup", false);
       AddonManagerPrivate.recordTimestamp("XPI_startup_end");
       this.extensionsActive = true;
       this.runPhase = XPI_BEFORE_UI_STARTUP;
     }
     catch (e) {
       logger.error("startup failed", e);
       AddonManagerPrivate.recordException("XPI", "startup failed", e);
     }
   },
   /**
    * Shuts down the database and releases all references.
    * Return: Promise{integer} resolves / rejects with the result of
    *                          flushing the XPI Database if it was loaded,
    *                          0 otherwise.
    */
   shutdown: function XPI_shutdown() {
     logger.debug("shutdown");
     // Stop anything we were doing asynchronously
     this.cancelAll();
     this.bootstrappedAddons = {};
     this.bootstrapScopes = {};
     this.enabledAddons = null;
     this.allAppGlobal = true;
     this.inactiveAddonIDs = [];
     // If there are pending operations then we must update the list of active
     // add-ons
     if (Prefs.getBoolPref(PREF_PENDING_OPERATIONS, false)) {
       XPIDatabase.updateActiveAddons();
       Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
                                  !XPIDatabase.writeAddonsList());
     }
     this.installs = null;
     this.installLocations = null;
     this.installLocationsByName = null;
     // This is needed to allow xpcshell tests to simulate a restart
     this.extensionsActive = false;
     // Remove URI mappings again
     delete this._uriMappings;
     if (gLazyObjectsLoaded) {
       let done = XPIDatabase.shutdown();
       done.then(
         ret => {
           logger.debug("Notifying XPI shutdown observers");
           Services.obs.notifyObservers(null, "xpi-provider-shutdown", null);
         },
         err => {
           logger.debug("Notifying XPI shutdown observers");
           this._shutdownError = err;
           Services.obs.notifyObservers(null, "xpi-provider-shutdown", err);
         }
       );
       return done;
     }
     else {
       logger.debug("Notifying XPI shutdown observers");
       Services.obs.notifyObservers(null, "xpi-provider-shutdown", null);
     }
   },
   /**
    * Applies any pending theme change to the preferences.
    */
   applyThemeChange: function XPI_applyThemeChange() {
     if (!Prefs.getBoolPref(PREF_DSS_SWITCHPENDING, false))
       return;
     // Tell the Chrome Registry which Skin to select
     try {
       this.selectedSkin = Prefs.getCharPref(PREF_DSS_SKIN_TO_SELECT);
       Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
                                  this.selectedSkin);
       Services.prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
       logger.debug("Changed skin to " + this.selectedSkin);
       this.currentSkin = this.selectedSkin;
     }
     catch (e) {
       logger.error("Error applying theme change", e);
     }
     Services.prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
   },
   /**
    * Shows the "Compatibility Updates" UI
    */
   showUpgradeUI: function XPI_showUpgradeUI() {
     // Flip a flag to indicate that we interrupted startup with an interactive prompt
     Services.startup.interrupted = true;
     if (!Prefs.getBoolPref(PREF_SHOWN_SELECTION_UI, false)) {
       // This *must* be modal as it has to block startup.
       var features = "chrome,centerscreen,dialog,titlebar,modal";
       Services.ww.openWindow(null, URI_EXTENSION_SELECT_DIALOG, "", features, null);
       Services.prefs.setBoolPref(PREF_SHOWN_SELECTION_UI, true);
     }
     else {
       var variant = Cc["@mozilla.org/variant;1"].
                     createInstance(Ci.nsIWritableVariant);
       variant.setFromVariant(this.inactiveAddonIDs);
       // This *must* be modal as it has to block startup.
       var features = "chrome,centerscreen,dialog,titlebar,modal";
       var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
                getService(Ci.nsIWindowWatcher);
       ww.openWindow(null, URI_EXTENSION_UPDATE_DIALOG, "", features, variant);
     }
     // Ensure any changes to the add-ons list are flushed to disk
     Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
                                !XPIDatabase.writeAddonsList());
   },
   /**
    * Persists changes to XPIProvider.bootstrappedAddons to its store (a pref).
    */
   persistBootstrappedAddons: function XPI_persistBootstrappedAddons() {
     // Experiments are disabled upon app load, so don't persist references.
     let filtered = {};
     for (let id in this.bootstrappedAddons) {
       let entry = this.bootstrappedAddons[id];
       if (entry.type == "experiment") {
         continue;
       }
       filtered[id] = entry;
     }
     Services.prefs.setCharPref(PREF_BOOTSTRAP_ADDONS,
                                JSON.stringify(filtered));
   },
   /**
    * Adds a list of currently active add-ons to the next crash report.
    */
   addAddonsToCrashReporter: function XPI_addAddonsToCrashReporter() {
     if (!("nsICrashReporter" in Ci) ||
         !(Services.appinfo instanceof Ci.nsICrashReporter))
       return;
     // In safe mode no add-ons are loaded so we should not include them in the
     // crash report
     if (Services.appinfo.inSafeMode)
       return;
     let data = this.enabledAddons;
     for (let id in this.bootstrappedAddons) {
       data += (data ? "," : "") + encodeURIComponent(id) + ":" +
               encodeURIComponent(this.bootstrappedAddons[id].version);
     }
     try {
       Services.appinfo.annotateCrashReport("Add-ons", data);
     }
     catch (e) { }
     Cu.import("resource://gre/modules/TelemetryPing.jsm", {}).TelemetryPing.setAddOns(data);
   },
   /**
    * Gets the add-on states for an install location.
    * This function may be expensive because of the recursiveLastModifiedTime call.
    *
    * @param  location
    *         The install location to retrieve the add-on states for
    * @return a dictionary mapping add-on IDs to objects with a descriptor
    *         property which contains the add-ons dir/file descriptor and an
    *         mtime property which contains the add-on's last modified time as
    *         the number of milliseconds since the epoch.
    */
   getAddonStates: function XPI_getAddonStates(aLocation) {
     let addonStates = {};
     for (let file of aLocation.addonLocations) {
       let scanStarted = Date.now();
       let id = aLocation.getIDForLocation(file);
       let unpacked = 0;
       let [modFile, modTime, items] = recursiveLastModifiedTime(file);
       addonStates[id] = {
         descriptor: file.persistentDescriptor,
         mtime: modTime
       };
       try {
         // get the install.rdf update time, if any
         file.append(FILE_INSTALL_MANIFEST);
         let rdfTime = file.lastModifiedTime;
         addonStates[id].rdfTime = rdfTime;
         unpacked = 1;
       }
       catch (e) { }
       this._mostRecentlyModifiedFile[id] = modFile;
       this.setTelemetry(id, "unpacked", unpacked);
       this.setTelemetry(id, "location", aLocation.name);
       this.setTelemetry(id, "scan_MS", Date.now() - scanStarted);
       this.setTelemetry(id, "scan_items", items);
     }
     return addonStates;
   },
   /**
    * Gets an array of install location states which uniquely describes all
    * installed add-ons with the add-on's InstallLocation name and last modified
    * time. This function may be expensive because of the getAddonStates() call.
    *
    * @return an array of add-on states for each install location. Each state
    *         is an object with a name property holding the location's name and
    *         an addons property holding the add-on states for the location
    */
   getInstallLocationStates: function XPI_getInstallLocationStates() {
     let states = [];
     this.installLocations.forEach(function(aLocation) {
       let addons = aLocation.addonLocations;
       if (addons.length == 0)
         return;
       let locationState = {
         name: aLocation.name,
         addons: this.getAddonStates(aLocation)
       };
       states.push(locationState);
     }, this);
     return states;
   },
   /**
    * Check the staging directories of install locations for any add-ons to be
    * installed or add-ons to be uninstalled.
    *
    * @param  aManifests
    *         A dictionary to add detected install manifests to for the purpose
    *         of passing through updated compatibility information
    * @return true if an add-on was installed or uninstalled
    */
   processPendingFileChanges: function XPI_processPendingFileChanges(aManifests) {
     let changed = false;
     this.installLocations.forEach(function(aLocation) {
       aManifests[aLocation.name] = {};
       // We can't install or uninstall anything in locked locations
       if (aLocation.locked)
         return;
       let stagedXPIDir = aLocation.getXPIStagingDir();
       let stagingDir = aLocation.getStagingDir();
       if (stagedXPIDir.exists() && stagedXPIDir.isDirectory()) {
         let entries = stagedXPIDir.directoryEntries
                                   .QueryInterface(Ci.nsIDirectoryEnumerator);
         while (entries.hasMoreElements()) {
           let stageDirEntry = entries.nextFile;
           if (!stageDirEntry.isDirectory()) {
             logger.warn("Ignoring file in XPI staging directory: " + stageDirEntry.path);
             continue;
           }
           // Find the last added XPI file in the directory
           let stagedXPI = null;
           var xpiEntries = stageDirEntry.directoryEntries
                                         .QueryInterface(Ci.nsIDirectoryEnumerator);
           while (xpiEntries.hasMoreElements()) {
             let file = xpiEntries.nextFile;
             if (file.isDirectory())
               continue;
             let extension = file.leafName;
             extension = extension.substring(extension.length - 4);
             if (extension != ".xpi" && extension != ".jar")
               continue;
             stagedXPI = file;
           }
           xpiEntries.close();
           if (!stagedXPI)
             continue;
           let addon = null;
           try {
             addon = loadManifestFromZipFile(stagedXPI);
           }
           catch (e) {
             logger.error("Unable to read add-on manifest from " + stagedXPI.path, e);
             continue;
           }
           logger.debug("Migrating staged install of " + addon.id + " in " + aLocation.name);
           if (addon.unpack || Prefs.getBoolPref(PREF_XPI_UNPACK, false)) {
             let targetDir = stagingDir.clone();
             targetDir.append(addon.id);
             try {
               targetDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
             }
             catch (e) {
               logger.error("Failed to create staging directory for add-on " + addon.id, e);
               continue;
             }
             try {
               ZipUtils.extractFiles(stagedXPI, targetDir);
             }
             catch (e) {
               logger.error("Failed to extract staged XPI for add-on " + addon.id + " in " +
                     aLocation.name, e);
             }
           }
           else {
             try {
               stagedXPI.moveTo(stagingDir, addon.id + ".xpi");
             }
             catch (e) {
               logger.error("Failed to move staged XPI for add-on " + addon.id + " in " +
                     aLocation.name, e);
             }
           }
         }
         entries.close();
       }
       if (stagedXPIDir.exists()) {
         try {
           recursiveRemove(stagedXPIDir);
         }
         catch (e) {
           // Non-critical, just saves some perf on startup if we clean this up.
           logger.debug("Error removing XPI staging dir " + stagedXPIDir.path, e);
         }
       }
       try {
         if (!stagingDir || !stagingDir.exists() || !stagingDir.isDirectory())
           return;
       }
       catch (e) {
         logger.warn("Failed to find staging directory", e);
         return;
       }
       let seenFiles = [];
       // Use a snapshot of the directory contents to avoid possible issues with
       // iterating over a directory while removing files from it (the YAFFS2
       // embedded filesystem has this issue, see bug 772238), and to remove
       // normal files before their resource forks on OSX (see bug 733436).
       let stagingDirEntries = getDirectoryEntries(stagingDir, true);
       for (let stageDirEntry of stagingDirEntries) {
         let id = stageDirEntry.leafName;
         let isDir;
         try {
           isDir = stageDirEntry.isDirectory();
         }
         catch (e if e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
           // If the file has already gone away then don't worry about it, this
           // can happen on OSX where the resource fork is automatically moved
           // with the data fork for the file. See bug 733436.
           continue;
         }
         if (!isDir) {
           if (id.substring(id.length - 4).toLowerCase() == ".xpi") {
             id = id.substring(0, id.length - 4);
           }
           else {
             if (id.substring(id.length - 5).toLowerCase() != ".json") {
               logger.warn("Ignoring file: " + stageDirEntry.path);
               seenFiles.push(stageDirEntry.leafName);
             }
             continue;
           }
         }
         // Check that the directory's name is a valid ID.
         if (!gIDTest.test(id)) {
           logger.warn("Ignoring directory whose name is not a valid add-on ID: " +
                stageDirEntry.path);
           seenFiles.push(stageDirEntry.leafName);
           continue;
         }
         changed = true;
         if (isDir) {
           // Check if the directory contains an install manifest.
           let manifest = stageDirEntry.clone();
           manifest.append(FILE_INSTALL_MANIFEST);
           // If the install manifest doesn't exist uninstall this add-on in this
           // install location.
           if (!manifest.exists()) {
             logger.debug("Processing uninstall of " + id + " in " + aLocation.name);
             try {
               aLocation.uninstallAddon(id);
               seenFiles.push(stageDirEntry.leafName);
             }
             catch (e) {
               logger.error("Failed to uninstall add-on " + id + " in " + aLocation.name, e);
             }
             // The file check later will spot the removal and cleanup the database
             continue;
           }
         }
         aManifests[aLocation.name][id] = null;
         let existingAddonID = id;
         let jsonfile = stagingDir.clone();
         jsonfile.append(id + ".json");
         try {
           aManifests[aLocation.name][id] = loadManifestFromFile(stageDirEntry);
         }
         catch (e) {
           logger.error("Unable to read add-on manifest from " + stageDirEntry.path, e);
           // This add-on can't be installed so just remove it now
           seenFiles.push(stageDirEntry.leafName);
           seenFiles.push(jsonfile.leafName);
           continue;
         }
         // Check for a cached metadata for this add-on, it may contain updated
         // compatibility information
         if (jsonfile.exists()) {
           logger.debug("Found updated metadata for " + id + " in " + aLocation.name);
           let fis = Cc["@mozilla.org/network/file-input-stream;1"].
                        createInstance(Ci.nsIFileInputStream);
           let json = Cc["@mozilla.org/dom/json;1"].
                      createInstance(Ci.nsIJSON);
           try {
             fis.init(jsonfile, -1, 0, 0);
             let metadata = json.decodeFromStream(fis, jsonfile.fileSize);
             aManifests[aLocation.name][id].importMetadata(metadata);
           }
           catch (e) {
             // If some data can't be recovered from the cached metadata then it
             // is unlikely to be a problem big enough to justify throwing away
             // the install, just log and error and continue
             logger.error("Unable to read metadata from " + jsonfile.path, e);
           }
           finally {
             fis.close();
           }
         }
         seenFiles.push(jsonfile.leafName);
         existingAddonID = aManifests[aLocation.name][id].existingAddonID || id;
         var oldBootstrap = null;
         logger.debug("Processing install of " + id + " in " + aLocation.name);
         if (existingAddonID in this.bootstrappedAddons) {
           try {
             var existingAddon = aLocation.getLocationForID(existingAddonID);
             if (this.bootstrappedAddons[existingAddonID].descriptor ==
                 existingAddon.persistentDescriptor) {
               oldBootstrap = this.bootstrappedAddons[existingAddonID];
               // We'll be replacing a currently active bootstrapped add-on so
               // call its uninstall method
               let newVersion = aManifests[aLocation.name][id].version;
               let oldVersion = oldBootstrap.version;
               let uninstallReason = Services.vc.compare(oldVersion, newVersion) < 0 ?
                                     BOOTSTRAP_REASONS.ADDON_UPGRADE :
                                     BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
               this.callBootstrapMethod(existingAddonID, oldBootstrap.version,
                                        oldBootstrap.type, existingAddon, "uninstall", uninstallReason,
                                        { newVersion: newVersion });
               this.unloadBootstrapScope(existingAddonID);
               flushStartupCache();
             }
           }
           catch (e) {
           }
         }
         try {
           var addonInstallLocation = aLocation.installAddon(id, stageDirEntry,
                                                             existingAddonID);
           if (aManifests[aLocation.name][id])
             aManifests[aLocation.name][id]._sourceBundle = addonInstallLocation;
         }
         catch (e) {
           logger.error("Failed to install staged add-on " + id + " in " + aLocation.name,
                 e);
           // Re-create the staged install
           AddonInstall.createStagedInstall(aLocation, stageDirEntry,
                                            aManifests[aLocation.name][id]);
           // Make sure not to delete the cached manifest json file
           seenFiles.pop();
           delete aManifests[aLocation.name][id];
           if (oldBootstrap) {
             // Re-install the old add-on
             this.callBootstrapMethod(existingAddonID, oldBootstrap.version,
                                      oldBootstrap.type, existingAddon, "install",
                                      BOOTSTRAP_REASONS.ADDON_INSTALL);
           }
           continue;
         }
       }
       try {
         aLocation.cleanStagingDir(seenFiles);
       }
       catch (e) {
         // Non-critical, just saves some perf on startup if we clean this up.
         logger.debug("Error cleaning staging dir " + stagingDir.path, e);
       }
     }, this);
     return changed;
   },
   /**
    * Installs any add-ons located in the extensions directory of the
    * application's distribution specific directory into the profile unless a
    * newer version already exists or the user has previously uninstalled the
    * distributed add-on.
    *
    * @param  aManifests
    *         A dictionary to add new install manifests to to save having to
    *         reload them later
    * @return true if any new add-ons were installed
    */
   installDistributionAddons: function XPI_installDistributionAddons(aManifests) {
     let distroDir;
     try {
       distroDir = FileUtils.getDir(KEY_APP_DISTRIBUTION, [DIR_EXTENSIONS]);
     }
     catch (e) {
       return false;
     }
     if (!distroDir.exists())
       return false;
     if (!distroDir.isDirectory())
       return false;
     let changed = false;
     let profileLocation = this.installLocationsByName[KEY_APP_PROFILE];
     let entries = distroDir.directoryEntries
                            .QueryInterface(Ci.nsIDirectoryEnumerator);
     let entry;
     while ((entry = entries.nextFile)) {
       let id = entry.leafName;
       if (entry.isFile()) {
         if (id.substring(id.length - 4).toLowerCase() == ".xpi") {
           id = id.substring(0, id.length - 4);
         }
         else {
           logger.debug("Ignoring distribution add-on that isn't an XPI: " + entry.path);
           continue;
         }
       }
       else if (!entry.isDirectory()) {
         logger.debug("Ignoring distribution add-on that isn't a file or directory: " +
             entry.path);
         continue;
       }
       if (!gIDTest.test(id)) {
         logger.debug("Ignoring distribution add-on whose name is not a valid add-on ID: " +
             entry.path);
         continue;
       }
       let addon;
       try {
         addon = loadManifestFromFile(entry);
       }
       catch (e) {
         logger.warn("File entry " + entry.path + " contains an invalid add-on", e);
         continue;
       }
       if (addon.id != id) {
         logger.warn("File entry " + entry.path + " contains an add-on with an " +
              "incorrect ID")
         continue;
       }
       let existingEntry = null;
       try {
         existingEntry = profileLocation.getLocationForID(id);
       }
       catch (e) {
       }
       if (existingEntry) {
         let existingAddon;
         try {
           existingAddon = loadManifestFromFile(existingEntry);
           if (Services.vc.compare(addon.version, existingAddon.version) <= 0)
             continue;
         }
         catch (e) {
           // Bad add-on in the profile so just proceed and install over the top
           logger.warn("Profile contains an add-on with a bad or missing install " +
                "manifest at " + existingEntry.path + ", overwriting", e);
         }
       }
       else if (Prefs.getBoolPref(PREF_BRANCH_INSTALLED_ADDON + id, false)) {
         continue;
       }
       // Install the add-on
       try {
         profileLocation.installAddon(id, entry, null, true);
         logger.debug("Installed distribution add-on " + id);
         Services.prefs.setBoolPref(PREF_BRANCH_INSTALLED_ADDON + id, true)
         // aManifests may contain a copy of a newly installed add-on's manifest
         // and we'll have overwritten that so instead cache our install manifest
         // which will later be put into the database in processFileChanges
         if (!(KEY_APP_PROFILE in aManifests))
           aManifests[KEY_APP_PROFILE] = {};
         aManifests[KEY_APP_PROFILE][id] = addon;
         changed = true;
       }
       catch (e) {
         logger.error("Failed to install distribution add-on " + entry.path, e);
       }
     }
     entries.close();
     return changed;
   },
   /**
    * Compares the add-ons that are currently installed to those that were
    * known to be installed when the application last ran and applies any
    * changes found to the database. Also sends "startupcache-invalidate" signal to
    * observerservice if it detects that data may have changed.
    *
    * @param  aState
    *         The array of current install location states
    * @param  aManifests
    *         A dictionary of cached AddonInstalls for add-ons that have been
    *         installed
    * @param  aUpdateCompatibility
    *         true to update add-ons appDisabled property when the application
    *         version has changed
    * @param  aOldAppVersion
    *         The version of the application last run with this profile or null
    *         if it is a new profile or the version is unknown
    * @param  aOldPlatformVersion
    *         The version of the platform last run with this profile or null
    *         if it is a new profile or the version is unknown
    * @return a boolean indicating if a change requiring flushing the caches was
    *         detected
    */
   processFileChanges: function XPI_processFileChanges(aState, aManifests,
                                                       aUpdateCompatibility,
                                                       aOldAppVersion,
                                                       aOldPlatformVersion) {
     let visibleAddons = {};
     let oldBootstrappedAddons = this.bootstrappedAddons;
     this.bootstrappedAddons = {};
     /**
      * Updates an add-on's metadata and determines if a restart of the
      * application is necessary. This is called when either the add-on's
      * install directory path or last modified time has changed.
      *
      * @param  aInstallLocation
      *         The install location containing the add-on
      * @param  aOldAddon
      *         The AddonInternal as it appeared the last time the application
      *         ran
      * @param  aAddonState
      *         The new state of the add-on
      * @return a boolean indicating if flushing caches is required to complete
      *         changing this add-on
      */
     function updateMetadata(aInstallLocation, aOldAddon, aAddonState) {
       logger.debug("Add-on " + aOldAddon.id + " modified in " + aInstallLocation.name);
       // Check if there is an updated install manifest for this add-on
       let newAddon = aManifests[aInstallLocation.name][aOldAddon.id];
       try {
         // If not load it
         if (!newAddon) {
           let file = aInstallLocation.getLocationForID(aOldAddon.id);
           newAddon = loadManifestFromFile(file);
           applyBlocklistChanges(aOldAddon, newAddon);
           // Carry over any pendingUninstall state to add-ons modified directly
           // in the profile. This is important when the attempt to remove the
           // add-on in processPendingFileChanges failed and caused an mtime
           // change to the add-ons files.
           newAddon.pendingUninstall = aOldAddon.pendingUninstall;
         }
         // The ID in the manifest that was loaded must match the ID of the old
         // add-on.
         if (newAddon.id != aOldAddon.id)
           throw new Error("Incorrect id in install manifest");
       }
       catch (e) {
         logger.warn("Add-on is invalid", e);
         XPIDatabase.removeAddonMetadata(aOldAddon);
         if (!aInstallLocation.locked)
           aInstallLocation.uninstallAddon(aOldAddon.id);
         else
           logger.warn("Could not uninstall invalid item from locked install location");
         // If this was an active add-on then we must force a restart
         if (aOldAddon.active)
           return true;
         return false;
       }
       // Set the additional properties on the new AddonInternal
       newAddon._installLocation = aInstallLocation;
       newAddon.updateDate = aAddonState.mtime;
       newAddon.visible = !(newAddon.id in visibleAddons);
       // Update the database
       let newDBAddon = XPIDatabase.updateAddonMetadata(aOldAddon, newAddon,
                                                        aAddonState.descriptor);
       if (newDBAddon.visible) {
         visibleAddons[newDBAddon.id] = newDBAddon;
         // Remember add-ons that were changed during startup
         AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
                                              newDBAddon.id);
         // If this was the active theme and it is now disabled then enable the
         // default theme
         if (aOldAddon.active && isAddonDisabled(newDBAddon))
           XPIProvider.enableDefaultTheme();
         // If the new add-on is bootstrapped and active then call its install method
         if (newDBAddon.active && newDBAddon.bootstrap) {
           // Startup cache must be flushed before calling the bootstrap script
           flushStartupCache();
           let installReason = Services.vc.compare(aOldAddon.version, newDBAddon.version) < 0 ?
                               BOOTSTRAP_REASONS.ADDON_UPGRADE :
                               BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
           let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
           file.persistentDescriptor = aAddonState.descriptor;
           XPIProvider.callBootstrapMethod(newDBAddon.id, newDBAddon.version,
                                           newDBAddon.type, file, "install",
                                           installReason, { oldVersion: aOldAddon.version });
           return false;
         }
         return true;
       }
       return false;
     }
     /**
      * Updates an add-on's descriptor for when the add-on has moved in the
      * filesystem but hasn't changed in any other way.
      *
      * @param  aInstallLocation
      *         The install location containing the add-on
      * @param  aOldAddon
      *         The AddonInternal as it appeared the last time the application
      *         ran
      * @param  aAddonState
      *         The new state of the add-on
      * @return a boolean indicating if flushing caches is required to complete
      *         changing this add-on
      */
     function updateDescriptor(aInstallLocation, aOldAddon, aAddonState) {
       logger.debug("Add-on " + aOldAddon.id + " moved to " + aAddonState.descriptor);
       aOldAddon.descriptor = aAddonState.descriptor;
       aOldAddon.visible = !(aOldAddon.id in visibleAddons);
       XPIDatabase.saveChanges();
       if (aOldAddon.visible) {
         visibleAddons[aOldAddon.id] = aOldAddon;
         if (aOldAddon.bootstrap && aOldAddon.active) {
           let bootstrap = oldBootstrappedAddons[aOldAddon.id];
           bootstrap.descriptor = aAddonState.descriptor;
           XPIProvider.bootstrappedAddons[aOldAddon.id] = bootstrap;
         }
         return true;
       }
       return false;
     }
     /**
      * Called when no change has been detected for an add-on's metadata. The
      * add-on may have become visible due to other add-ons being removed or
      * the add-on may need to be updated when the application version has
      * changed.
      *
      * @param  aInstallLocation
      *         The install location containing the add-on
      * @param  aOldAddon
      *         The AddonInternal as it appeared the last time the application
      *         ran
      * @param  aAddonState
      *         The new state of the add-on
      * @return a boolean indicating if flushing caches is required to complete
      *         changing this add-on
      */
     function updateVisibilityAndCompatibility(aInstallLocation, aOldAddon,
                                               aAddonState) {
       let changed = false;
       // This add-ons metadata has not changed but it may have become visible
       if (!(aOldAddon.id in visibleAddons)) {
         visibleAddons[aOldAddon.id] = aOldAddon;
         if (!aOldAddon.visible) {
           // Remember add-ons that were changed during startup.
           AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
                                                aOldAddon.id);
           XPIDatabase.makeAddonVisible(aOldAddon);
           if (aOldAddon.bootstrap) {
             // The add-on is bootstrappable so call its install script
             let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
             file.persistentDescriptor = aAddonState.descriptor;
             XPIProvider.callBootstrapMethod(aOldAddon.id, aOldAddon.version, aOldAddon.type, file,
                                             "install",
                                             BOOTSTRAP_REASONS.ADDON_INSTALL);
             // If it should be active then mark it as active otherwise unload
             // its scope
             if (!isAddonDisabled(aOldAddon)) {
               XPIDatabase.updateAddonActive(aOldAddon, true);
             }
             else {
               XPIProvider.unloadBootstrapScope(newAddon.id);
             }
           }
           else {
             // Otherwise a restart is necessary
             changed = true;
           }
         }
       }
       // App version changed, we may need to update the appDisabled property.
       if (aUpdateCompatibility) {
         let wasDisabled = isAddonDisabled(aOldAddon);
         let wasAppDisabled = aOldAddon.appDisabled;
         let wasUserDisabled = aOldAddon.userDisabled;
         let wasSoftDisabled = aOldAddon.softDisabled;
         // This updates the addon's JSON cached data in place
         applyBlocklistChanges(aOldAddon, aOldAddon, aOldAppVersion,
                               aOldPlatformVersion);
         aOldAddon.appDisabled = !isUsableAddon(aOldAddon);
         let isDisabled = isAddonDisabled(aOldAddon);
         // If either property has changed update the database.
         if (wasAppDisabled != aOldAddon.appDisabled ||
             wasUserDisabled != aOldAddon.userDisabled ||
             wasSoftDisabled != aOldAddon.softDisabled) {
           logger.debug("Add-on " + aOldAddon.id + " changed appDisabled state to " +
               aOldAddon.appDisabled + ", userDisabled state to " +
               aOldAddon.userDisabled + " and softDisabled state to " +
               aOldAddon.softDisabled);
           XPIDatabase.saveChanges();
         }
         // If this is a visible add-on and it has changed disabled state then we
         // may need a restart or to update the bootstrap list.
         if (aOldAddon.visible && wasDisabled != isDisabled) {
           // Remember add-ons that became disabled or enabled by the application
           // change
           let change = isDisabled ? AddonManager.STARTUP_CHANGE_DISABLED
                                   : AddonManager.STARTUP_CHANGE_ENABLED;
           AddonManagerPrivate.addStartupChange(change, aOldAddon.id);
           if (aOldAddon.bootstrap) {
             // Update the add-ons active state
             XPIDatabase.updateAddonActive(aOldAddon, !isDisabled);
           }
           else {
             changed = true;
           }
         }
       }
       if (aOldAddon.visible && aOldAddon.active && aOldAddon.bootstrap) {
         XPIProvider.bootstrappedAddons[aOldAddon.id] = {
           version: aOldAddon.version,
           type: aOldAddon.type,
           descriptor: aAddonState.descriptor
         };
       }
       return changed;
     }
     /**
      * Called when an add-on has been removed.
      *
      * @param  aOldAddon
      *         The AddonInternal as it appeared the last time the application
      *         ran
      * @return a boolean indicating if flushing caches is required to complete
      *         changing this add-on
      */
     function removeMetadata(aOldAddon) {
       // This add-on has disappeared
       logger.debug("Add-on " + aOldAddon.id + " removed from " + aOldAddon.location);
       XPIDatabase.removeAddonMetadata(aOldAddon);
       // Remember add-ons that were uninstalled during startup
       if (aOldAddon.visible) {
         AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_UNINSTALLED,
                                              aOldAddon.id);
       }
       else if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
                            .indexOf(aOldAddon.id) != -1) {
         AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
                                              aOldAddon.id);
       }
       if (aOldAddon.active) {
         // Enable the default theme if the previously active theme has been
         // removed
         if (aOldAddon.type == "theme")
           XPIProvider.enableDefaultTheme();
         return true;
       }
       return false;
     }
     /**
      * Called to add the metadata for an add-on in one of the install locations
      * to the database. This can be called in three different cases. Either an
      * add-on has been dropped into the location from outside of Firefox, or
      * an add-on has been installed through the application, or the database
      * has been upgraded or become corrupt and add-on data has to be reloaded
      * into it.
      *
      * @param  aInstallLocation
      *         The install location containing the add-on
      * @param  aId
      *         The ID of the add-on
      * @param  aAddonState
      *         The new state of the add-on
      * @param  aMigrateData
      *         If during startup the database had to be upgraded this will
      *         contain data that used to be held about this add-on
      * @return a boolean indicating if flushing caches is required to complete
      *         changing this add-on
      */
     function addMetadata(aInstallLocation, aId, aAddonState, aMigrateData) {
       logger.debug("New add-on " + aId + " installed in " + aInstallLocation.name);
       let newAddon = null;
       let sameVersion = false;
       // Check the updated manifests lists for the install location, If there
       // is no manifest for the add-on ID then newAddon will be undefined
       if (aInstallLocation.name in aManifests)
         newAddon = aManifests[aInstallLocation.name][aId];
       // If we had staged data for this add-on or we aren't recovering from a
       // corrupt database and we don't have migration data for this add-on then
       // this must be a new install.
       let isNewInstall = (!!newAddon) || (!XPIDatabase.activeBundles && !aMigrateData);
       // If it's a new install and we haven't yet loaded the manifest then it
       // must be something dropped directly into the install location
       let isDetectedInstall = isNewInstall && !newAddon;
       // Load the manifest if necessary and sanity check the add-on ID
       try {
         if (!newAddon) {
           // Load the manifest from the add-on.
           let file = aInstallLocation.getLocationForID(aId);
           newAddon = loadManifestFromFile(file);
         }
         // The add-on in the manifest should match the add-on ID.
         if (newAddon.id != aId) {
           throw new Error("Invalid addon ID: expected addon ID " + aId +
                           ", found " + newAddon.id + " in manifest");
         }
       }
       catch (e) {
         logger.warn("Add-on is invalid", e);
         // Remove the invalid add-on from the install location if the install
         // location isn't locked, no restart will be necessary
         if (!aInstallLocation.locked)
           aInstallLocation.uninstallAddon(aId);
         else
           logger.warn("Could not uninstall invalid item from locked install location");
         return false;
       }
       // Update the AddonInternal properties.
       newAddon._installLocation = aInstallLocation;
       newAddon.visible = !(newAddon.id in visibleAddons);
       newAddon.installDate = aAddonState.mtime;
       newAddon.updateDate = aAddonState.mtime;
       newAddon.foreignInstall = isDetectedInstall;
       if (aMigrateData) {
         // If there is migration data then apply it.
         logger.debug("Migrating data from old database");
         DB_MIGRATE_METADATA.forEach(function(aProp) {
           // A theme's disabled state is determined by the selected theme
           // preference which is read in loadManifestFromRDF
           if (aProp == "userDisabled" && newAddon.type == "theme")
             return;
           if (aProp in aMigrateData)
             newAddon[aProp] = aMigrateData[aProp];
         });
         // Force all non-profile add-ons to be foreignInstalls since they can't
         // have been installed through the API
         newAddon.foreignInstall |= aInstallLocation.name != KEY_APP_PROFILE;
         // Some properties should only be migrated if the add-on hasn't changed.
         // The version property isn't a perfect check for this but covers the
         // vast majority of cases.
         if (aMigrateData.version == newAddon.version) {
           logger.debug("Migrating compatibility info");
           sameVersion = true;
           if ("targetApplications" in aMigrateData)
             newAddon.applyCompatibilityUpdate(aMigrateData, true);
         }
         // Since the DB schema has changed make sure softDisabled is correct
         applyBlocklistChanges(newAddon, newAddon, aOldAppVersion,
                               aOldPlatformVersion);
       }
       // The default theme is never a foreign install
       if (newAddon.type == "theme" && newAddon.internalName == XPIProvider.defaultSkin)
         newAddon.foreignInstall = false;
       if (isDetectedInstall && newAddon.foreignInstall) {
         // If the add-on is a foreign install and is in a scope where add-ons
         // that were dropped in should default to disabled then disable it
         let disablingScopes = Prefs.getIntPref(PREF_EM_AUTO_DISABLED_SCOPES, 0);
         if (aInstallLocation.scope & disablingScopes)
           newAddon.userDisabled = true;
       }
       // If we have a list of what add-ons should be marked as active then use
       // it to guess at migration data.
       if (!isNewInstall && XPIDatabase.activeBundles) {
         // For themes we know which is active by the current skin setting
         if (newAddon.type == "theme")
           newAddon.active = newAddon.internalName == XPIProvider.currentSkin;
         else
           newAddon.active = XPIDatabase.activeBundles.indexOf(aAddonState.descriptor) != -1;
         // If the add-on wasn't active and it isn't already disabled in some way
         // then it was probably either softDisabled or userDisabled
         if (!newAddon.active && newAddon.visible && !isAddonDisabled(newAddon)) {
           // If the add-on is softblocked then assume it is softDisabled
           if (newAddon.blocklistState == Ci.nsIBlocklistService.STATE_SOFTBLOCKED)
             newAddon.softDisabled = true;
           else
             newAddon.userDisabled = true;
         }
       }
       else {
         newAddon.active = (newAddon.visible && !isAddonDisabled(newAddon))
       }
       let newDBAddon = XPIDatabase.addAddonMetadata(newAddon, aAddonState.descriptor);
       if (newDBAddon.visible) {
         // Remember add-ons that were first detected during startup.
         if (isDetectedInstall) {
           // If a copy from a higher priority location was removed then this
           // add-on has changed
           if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_UNINSTALLED)
                           .indexOf(newDBAddon.id) != -1) {
             AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
                                                  newDBAddon.id);
           }
           else {
             AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED,
                                                  newDBAddon.id);
           }
         }
         // Note if any visible add-on is not in the application install location
         if (newDBAddon._installLocation.name != KEY_APP_GLOBAL)
           XPIProvider.allAppGlobal = false;
         visibleAddons[newDBAddon.id] = newDBAddon;
         let installReason = BOOTSTRAP_REASONS.ADDON_INSTALL;
         let extraParams = {};
         // If we're hiding a bootstrapped add-on then call its uninstall method
         if (newDBAddon.id in oldBootstrappedAddons) {
           let oldBootstrap = oldBootstrappedAddons[newDBAddon.id];
           extraParams.oldVersion = oldBootstrap.version;
           XPIProvider.bootstrappedAddons[newDBAddon.id] = oldBootstrap;
           // If the old version is the same as the new version, or we're
           // recovering from a corrupt DB, don't call uninstall and install
           // methods.
           if (sameVersion || !isNewInstall)
             return false;
           installReason = Services.vc.compare(oldBootstrap.version, newDBAddon.version) < 0 ?
                           BOOTSTRAP_REASONS.ADDON_UPGRADE :
                           BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
           let oldAddonFile = Cc["@mozilla.org/file/local;1"].
                              createInstance(Ci.nsIFile);
           oldAddonFile.persistentDescriptor = oldBootstrap.descriptor;
           XPIProvider.callBootstrapMethod(newDBAddon.id, oldBootstrap.version,
                                           oldBootstrap.type, oldAddonFile, "uninstall",
                                           installReason, { newVersion: newDBAddon.version });
           XPIProvider.unloadBootstrapScope(newDBAddon.id);
           // If the new add-on is bootstrapped then we must flush the caches
           // before calling the new bootstrap script
           if (newDBAddon.bootstrap)
             flushStartupCache();
         }
         if (!newDBAddon.bootstrap)
           return true;
         // Visible bootstrapped add-ons need to have their install method called
         let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
         file.persistentDescriptor = aAddonState.descriptor;
         XPIProvider.callBootstrapMethod(newDBAddon.id, newDBAddon.version, newDBAddon.type, file,
                                         "install", installReason, extraParams);
         if (!newDBAddon.active)
           XPIProvider.unloadBootstrapScope(newDBAddon.id);
       }
       return false;
     }
     let changed = false;
     let knownLocations = XPIDatabase.getInstallLocations();
     // The install locations are iterated in reverse order of priority so when
     // there are multiple add-ons installed with the same ID the one that
     // should be visible is the first one encountered.
     for (let aSt of aState.reverse()) {
       // We can't include the install location directly in the state as it has
       // to be cached as JSON.
       let installLocation = this.installLocationsByName[aSt.name];
       let addonStates = aSt.addons;
       // Check if the database knows about any add-ons in this install location.
       if (knownLocations.has(installLocation.name)) {
         knownLocations.delete(installLocation.name);
         let addons = XPIDatabase.getAddonsInLocation(installLocation.name);
         // Iterate through the add-ons installed the last time the application
         // ran
         for (let aOldAddon of addons) {
           // If a version of this add-on has been installed in an higher
           // priority install location then count it as changed
           if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
                           .indexOf(aOldAddon.id) != -1) {
             AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
                                                  aOldAddon.id);
           }
           // Check if the add-on is still installed
           if (aOldAddon.id in addonStates) {
             let addonState = addonStates[aOldAddon.id];
             delete addonStates[aOldAddon.id];
             // Remember add-ons that were inactive during startup
             if (aOldAddon.visible && !aOldAddon.active)
               XPIProvider.inactiveAddonIDs.push(aOldAddon.id);
             // record a bit more per-addon telemetry
             let loc = aOldAddon.defaultLocale;
             if (loc) {
               XPIProvider.setTelemetry(aOldAddon.id, "name", loc.name);
               XPIProvider.setTelemetry(aOldAddon.id, "creator", loc.creator);
             }
             // Check if the add-on has been changed outside the XPI provider
             if (aOldAddon.updateDate != addonState.mtime) {
               // Did time change in the wrong direction?
               if (addonState.mtime < aOldAddon.updateDate) {
                 this.setTelemetry(aOldAddon.id, "olderFile", {
                   name: this._mostRecentlyModifiedFile[aOldAddon.id],
                   mtime: addonState.mtime,
                   oldtime: aOldAddon.updateDate
                 });
               }
               // Is the add-on unpacked?
               else if (addonState.rdfTime) {
                 // Was the addon manifest "install.rdf" modified, or some other file?
                 if (addonState.rdfTime > aOldAddon.updateDate) {
                   this.setTelemetry(aOldAddon.id, "modifiedInstallRDF", 1);
                 }
                 else {
                   this.setTelemetry(aOldAddon.id, "modifiedFile",
                                     this._mostRecentlyModifiedFile[aOldAddon.id]);
                 }
               }
               else {
                 this.setTelemetry(aOldAddon.id, "modifiedXPI", 1);
               }
             }
             // The add-on has changed if the modification time has changed, or
             // we have an updated manifest for it. Also reload the metadata for
             // add-ons in the application directory when the application version
             // has changed
             if (aOldAddon.id in aManifests[installLocation.name] ||
                 aOldAddon.updateDate != addonState.mtime ||
                 (aUpdateCompatibility && installLocation.name == KEY_APP_GLOBAL)) {
               changed = updateMetadata(installLocation, aOldAddon, addonState) ||
                         changed;
             }
             else if (aOldAddon.descriptor != addonState.descriptor) {
               changed = updateDescriptor(installLocation, aOldAddon, addonState) ||
                         changed;
             }
             else {
               changed = updateVisibilityAndCompatibility(installLocation,
                                                          aOldAddon, addonState) ||
                         changed;
             }
             if (aOldAddon.visible && aOldAddon._installLocation.name != KEY_APP_GLOBAL)
               XPIProvider.allAppGlobal = false;
           }
           else {
             changed = removeMetadata(aOldAddon) || changed;
           }
         }
       }
       // All the remaining add-ons in this install location must be new.
       // Get the migration data for this install location.
       let locMigrateData = {};
       if (XPIDatabase.migrateData && installLocation.name in XPIDatabase.migrateData)
         locMigrateData = XPIDatabase.migrateData[installLocation.name];
       for (let id in addonStates) {
         changed = addMetadata(installLocation, id, addonStates[id],
                               (locMigrateData[id] || null)) || changed;
       }
     }
     // The remaining locations that had add-ons installed in them no longer
     // have any add-ons installed in them, or the locations no longer exist.
     // The metadata for the add-ons that were in them must be removed from the
     // database.
     for (let location of knownLocations) {
       let addons = XPIDatabase.getAddonsInLocation(location);
       for (let aOldAddon of addons) {
         changed = removeMetadata(aOldAddon) || changed;
       }
     }
     // Cache the new install location states
     this.installStates = this.getInstallLocationStates();
     let cache = JSON.stringify(this.installStates);
     Services.prefs.setCharPref(PREF_INSTALL_CACHE, cache);
     this.persistBootstrappedAddons();
     // Clear out any cached migration data.
     XPIDatabase.migrateData = null;
     return changed;
   },
   /**
    * Imports the xpinstall permissions from preferences into the permissions
    * manager for the user to change later.
    */
   importPermissions: function XPI_importPermissions() {
     PermissionsUtils.importFromPrefs(PREF_XPI_PERMISSIONS_BRANCH,
                                      XPI_PERMISSION);
   },
   /**
    * Checks for any changes that have occurred since the last time the
    * application was launched.
    *
    * @param  aAppChanged
    *         A tri-state value. Undefined means the current profile was created
    *         for this session, true means the profile already existed but was
    *         last used with an application with a different version number,
    *         false means that the profile was last used by this version of the
    *         application.
    * @param  aOldAppVersion
    *         The version of the application last run with this profile or null
    *         if it is a new profile or the version is unknown
    * @param  aOldPlatformVersion
    *         The version of the platform last run with this profile or null
    *         if it is a new profile or the version is unknown
    * @return true if a change requiring a restart was detected
    */
   checkForChanges: function XPI_checkForChanges(aAppChanged, aOldAppVersion,
                                                 aOldPlatformVersion) {
     logger.debug("checkForChanges");
     // Keep track of whether and why we need to open and update the database at
     // startup time.
     let updateReasons = [];
     if (aAppChanged) {
       updateReasons.push("appChanged");
     }
     // Load the list of bootstrapped add-ons first so processFileChanges can
     // modify it
     try {
       this.bootstrappedAddons = JSON.parse(Prefs.getCharPref(PREF_BOOTSTRAP_ADDONS,
                                            "{}"));
     } catch (e) {
       logger.warn("Error parsing enabled bootstrapped extensions cache", e);
     }
     // First install any new add-ons into the locations, if there are any
     // changes then we must update the database with the information in the
     // install locations
     let manifests = {};
     let updated = this.processPendingFileChanges(manifests);
     if (updated) {
       updateReasons.push("pendingFileChanges");
     }
     // This will be true if the previous session made changes that affect the
     // active state of add-ons but didn't commit them properly (normally due
     // to the application crashing)
     let hasPendingChanges = Prefs.getBoolPref(PREF_PENDING_OPERATIONS);
     if (hasPendingChanges) {
       updateReasons.push("hasPendingChanges");
     }
     // If the application has changed then check for new distribution add-ons
     if (aAppChanged !== false &&
         Prefs.getBoolPref(PREF_INSTALL_DISTRO_ADDONS, true))
     {
       updated = this.installDistributionAddons(manifests);
       if (updated) {
         updateReasons.push("installDistributionAddons");
       }
     }
     // Telemetry probe added around getInstallLocationStates() to check perf
     let telemetryCaptureTime = Date.now();
     this.installStates = this.getInstallLocationStates();
     let telemetry = Services.telemetry;
     telemetry.getHistogramById("CHECK_ADDONS_MODIFIED_MS").add(Date.now() - telemetryCaptureTime);
     // If the install directory state has changed then we must update the database
     let cache = Prefs.getCharPref(PREF_INSTALL_CACHE, "[]");
     // For a little while, gather telemetry on whether the deep comparison
     // makes a difference
     let newState = JSON.stringify(this.installStates);
     if (cache != newState) {
       logger.debug("Directory state JSON differs: cache " + cache + " state " + newState);
       if (directoryStateDiffers(this.installStates, cache)) {
         updateReasons.push("directoryState");
       }
       else {
         AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_state_badCompare", 1);
       }
     }
     // If the schema appears to have changed then we should update the database
     if (DB_SCHEMA != Prefs.getIntPref(PREF_DB_SCHEMA, 0)) {
       // If we don't have any add-ons, just update the pref, since we don't need to
       // write the database
       if (this.installStates.length == 0) {
         logger.debug("Empty XPI database, setting schema version preference to " + DB_SCHEMA);
         Services.prefs.setIntPref(PREF_DB_SCHEMA, DB_SCHEMA);
       }
       else {
         updateReasons.push("schemaChanged");
       }
     }
     // If the database doesn't exist and there are add-ons installed then we
     // must update the database however if there are no add-ons then there is
     // no need to update the database.
     let dbFile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true);
     if (!dbFile.exists() && this.installStates.length > 0) {
       updateReasons.push("needNewDatabase");
     }
     if (updateReasons.length == 0) {
       let bootstrapDescriptors = [this.bootstrappedAddons[b].descriptor
                                   for (b in this.bootstrappedAddons)];
       this.installStates.forEach(function(aInstallLocationState) {
         for (let id in aInstallLocationState.addons) {
           let pos = bootstrapDescriptors.indexOf(aInstallLocationState.addons[id].descriptor);
           if (pos != -1)
             bootstrapDescriptors.splice(pos, 1);
         }
       });
       if (bootstrapDescriptors.length > 0) {
         logger.warn("Bootstrap state is invalid (missing add-ons: " + bootstrapDescriptors.toSource() + ")");
         updateReasons.push("missingBootstrapAddon");
       }
     }
     // Catch and log any errors during the main startup
     try {
       let extensionListChanged = false;
       // If the database needs to be updated then open it and then update it
       // from the filesystem
       if (updateReasons.length > 0) {
         AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_load_reasons", updateReasons);
         XPIDatabase.syncLoadDB(false);
         try {
           extensionListChanged = this.processFileChanges(this.installStates, manifests,
                                                          aAppChanged,
                                                          aOldAppVersion,
                                                          aOldPlatformVersion);
         }
         catch (e) {
           logger.error("Failed to process extension changes at startup", e);
         }
       }
       if (aAppChanged) {
         // When upgrading the app and using a custom skin make sure it is still
         // compatible otherwise switch back the default
         if (this.currentSkin != this.defaultSkin) {
           let oldSkin = XPIDatabase.getVisibleAddonForInternalName(this.currentSkin);
           if (!oldSkin || isAddonDisabled(oldSkin))
             this.enableDefaultTheme();
         }
         // When upgrading remove the old extensions cache to force older
         // versions to rescan the entire list of extensions
         try {
           let oldCache = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_CACHE], true);
           if (oldCache.exists())
             oldCache.remove(true);
         }
         catch (e) {
           logger.warn("Unable to remove old extension cache " + oldCache.path, e);
         }
       }
       // If the application crashed before completing any pending operations then
       // we should perform them now.
       if (extensionListChanged || hasPendingChanges) {
         logger.debug("Updating database with changes to installed add-ons");
         XPIDatabase.updateActiveAddons();
         Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
                                    !XPIDatabase.writeAddonsList());
         Services.prefs.setCharPref(PREF_BOOTSTRAP_ADDONS,
                                    JSON.stringify(this.bootstrappedAddons));
         return true;
       }
       logger.debug("No changes found");
     }
     catch (e) {
       logger.error("Error during startup file checks", e);
     }
     // Check that the add-ons list still exists
     let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST],
                                        true);
     if (addonsList.exists() == (this.installStates.length == 0)) {
       logger.debug("Add-ons list is invalid, rebuilding");
       XPIDatabase.writeAddonsList();
     }
     return false;
   },
   /**
    * Called to test whether this provider supports installing a particular
    * mimetype.
    *
    * @param  aMimetype
    *         The mimetype to check for
    * @return true if the mimetype is application/x-xpinstall
    */
   supportsMimetype: function XPI_supportsMimetype(aMimetype) {
     return aMimetype == "application/x-xpinstall";
   },
   /**
    * Called to test whether installing XPI add-ons is enabled.
    *
    * @return true if installing is enabled
    */
   isInstallEnabled: function XPI_isInstallEnabled() {
     // Default to enabled if the preference does not exist
     return Prefs.getBoolPref(PREF_XPI_ENABLED, true);
   },
   /**
    * Called to test whether installing XPI add-ons by direct URL requests is
    * whitelisted.
    *
    * @return true if installing by direct requests is whitelisted
    */
   isDirectRequestWhitelisted: function XPI_isDirectRequestWhitelisted() {
     // Default to whitelisted if the preference does not exist.
     return Prefs.getBoolPref(PREF_XPI_DIRECT_WHITELISTED, true);
   },
   /**
    * Called to test whether installing XPI add-ons from file referrers is
    * whitelisted.
    *
    * @return true if installing from file referrers is whitelisted
    */
   isFileRequestWhitelisted: function XPI_isFileRequestWhitelisted() {
     // Default to whitelisted if the preference does not exist.
     return Prefs.getBoolPref(PREF_XPI_FILE_WHITELISTED, true);
   },
   /**
    * Called to test whether installing XPI add-ons from a URI is allowed.
    *
    * @param  aUri
    *         The URI being installed from
    * @return true if installing is allowed
    */
   isInstallAllowed: function XPI_isInstallAllowed(aUri) {
     if (!this.isInstallEnabled())
       return false;
     // Direct requests without a referrer are either whitelisted or blocked.
     if (!aUri)
       return this.isDirectRequestWhitelisted();
     // Local referrers can be whitelisted.
     if (this.isFileRequestWhitelisted() &&
         (aUri.schemeIs("chrome") || aUri.schemeIs("file")))
       return true;
     this.importPermissions();
     let permission = Services.perms.testPermission(aUri, XPI_PERMISSION);
     if (permission == Ci.nsIPermissionManager.DENY_ACTION)
       return false;
     let requireWhitelist = Prefs.getBoolPref(PREF_XPI_WHITELIST_REQUIRED, true);
     if (requireWhitelist && (permission != Ci.nsIPermissionManager.ALLOW_ACTION))
       return false;
     return true;
   },
   /**
    * Called to get an AddonInstall to download and install an add-on from a URL.
    *
    * @param  aUrl
    *         The URL to be installed
    * @param  aHash
    *         A hash for the install
    * @param  aName
    *         A name for the install
    * @param  aIcons
    *         Icon URLs for the install
    * @param  aVersion
    *         A version for the install
    * @param  aLoadGroup
    *         An nsILoadGroup to associate requests with
    * @param  aCallback
    *         A callback to pass the AddonInstall to
    */
   getInstallForURL: function XPI_getInstallForURL(aUrl, aHash, aName, aIcons,
                                                   aVersion, aLoadGroup, aCallback) {
     AddonInstall.createDownload(function getInstallForURL_createDownload(aInstall) {
       aCallback(aInstall.wrapper);
     }, aUrl, aHash, aName, aIcons, aVersion, aLoadGroup);
   },
   /**
    * Called to get an AddonInstall to install an add-on from a local file.
    *
    * @param  aFile
    *         The file to be installed
    * @param  aCallback
    *         A callback to pass the AddonInstall to
    */
   getInstallForFile: function XPI_getInstallForFile(aFile, aCallback) {
     AddonInstall.createInstall(function getInstallForFile_createInstall(aInstall) {
       if (aInstall)
         aCallback(aInstall.wrapper);
       else
         aCallback(null);
     }, aFile);
   },
   /**
    * Removes an AddonInstall from the list of active installs.
    *
    * @param  install
    *         The AddonInstall to remove
    */
   removeActiveInstall: function XPI_removeActiveInstall(aInstall) {
     this.installs = this.installs.filter(function installFilter(i) i != aInstall);
   },
   /**
    * Called to get an Addon with a particular ID.
    *
    * @param  aId
    *         The ID of the add-on to retrieve
    * @param  aCallback
    *         A callback to pass the Addon to
    */
   getAddonByID: function XPI_getAddonByID(aId, aCallback) {
     XPIDatabase.getVisibleAddonForID (aId, function getAddonByID_getVisibleAddonForID(aAddon) {
       aCallback(createWrapper(aAddon));
     });
   },
   /**
    * Called to get Addons of a particular type.
    *
    * @param  aTypes
    *         An array of types to fetch. Can be null to get all types.
    * @param  aCallback
    *         A callback to pass an array of Addons to
    */
   getAddonsByTypes: function XPI_getAddonsByTypes(aTypes, aCallback) {
     XPIDatabase.getVisibleAddons(aTypes, function getAddonsByTypes_getVisibleAddons(aAddons) {
       aCallback([createWrapper(a) for each (a in aAddons)]);
     });
   },
   /**
    * Obtain an Addon having the specified Sync GUID.
    *
    * @param  aGUID
    *         String GUID of add-on to retrieve
    * @param  aCallback
    *         A callback to pass the Addon to. Receives null if not found.
    */
   getAddonBySyncGUID: function XPI_getAddonBySyncGUID(aGUID, aCallback) {
     XPIDatabase.getAddonBySyncGUID(aGUID, function getAddonBySyncGUID_getAddonBySyncGUID(aAddon) {
       aCallback(createWrapper(aAddon));
     });
   },
   /**
    * Called to get Addons that have pending operations.
    *
    * @param  aTypes
    *         An array of types to fetch. Can be null to get all types
    * @param  aCallback
    *         A callback to pass an array of Addons to
    */
   getAddonsWithOperationsByTypes:
   function XPI_getAddonsWithOperationsByTypes(aTypes, aCallback) {
     XPIDatabase.getVisibleAddonsWithPendingOperations(aTypes,
       function getAddonsWithOpsByTypes_getVisibleAddonsWithPendingOps(aAddons) {
       let results = [createWrapper(a) for each (a in aAddons)];
       XPIProvider.installs.forEach(function(aInstall) {
         if (aInstall.state == AddonManager.STATE_INSTALLED &&
             !(aInstall.addon.inDatabase))
           results.push(createWrapper(aInstall.addon));
       });
       aCallback(results);
     });
   },
   /**
    * Called to get the current AddonInstalls, optionally limiting to a list of
    * types.
    *
    * @param  aTypes
    *         An array of types or null to get all types
    * @param  aCallback
    *         A callback to pass the array of AddonInstalls to
    */
   getInstallsByTypes: function XPI_getInstallsByTypes(aTypes, aCallback) {
     let results = [];
     this.installs.forEach(function(aInstall) {
       if (!aTypes || aTypes.indexOf(aInstall.type) >= 0)
         results.push(aInstall.wrapper);
     });
     aCallback(results);
   },
   /**
    * 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 or null
    * @return string containing the Addon ID
    * @see    AddonManager.mapURIToAddonID
    * @see    amIAddonManager.mapURIToAddonID
    */
   mapURIToAddonID: function XPI_mapURIToAddonID(aURI) {
     this._ensureURIMappings();
     let resolved = this._resolveURIToFile(aURI);
     if (!resolved) {
       return null;
     }
     resolved = resolved.spec;
     for (let [id, spec] in Iterator(this._uriMappings)) {
       if (resolved.startsWith(spec)) {
         return id;
       }
     }
     return null;
   },
   /**
    * Called when a new add-on has been enabled when only one add-on of that type
    * can be enabled.
    *
    * @param  aId
    *         The ID of the newly enabled add-on
    * @param  aType
    *         The type of the newly enabled add-on
    * @param  aPendingRestart
    *         true if the newly enabled add-on will only become enabled after a
    *         restart
    */
   addonChanged: function XPI_addonChanged(aId, aType, aPendingRestart) {
     // We only care about themes in this provider
     if (aType != "theme")
       return;
     if (!aId) {
       // Fallback to the default theme when no theme was enabled
       this.enableDefaultTheme();
       return;
     }
     // Look for the previously enabled theme and find the internalName of the
     // currently selected theme
     let previousTheme = null;
     let newSkin = this.defaultSkin;
     let addons = XPIDatabase.getAddonsByType("theme");
     addons.forEach(function(aTheme) {
       if (!aTheme.visible)
         return;
       if (aTheme.id == aId)
         newSkin = aTheme.internalName;
       else if (aTheme.userDisabled == false && !aTheme.pendingUninstall)
         previousTheme = aTheme;
     }, this);
     if (aPendingRestart) {
       Services.prefs.setBoolPref(PREF_DSS_SWITCHPENDING, true);
       Services.prefs.setCharPref(PREF_DSS_SKIN_TO_SELECT, newSkin);
     }
     else if (newSkin == this.currentSkin) {
       try {
         Services.prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
       }
       catch (e) { }
       try {
         Services.prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
       }
       catch (e) { }
     }
     else {
       Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN, newSkin);
       this.currentSkin = newSkin;
     }
     this.selectedSkin = newSkin;
     // Flush the preferences to disk so they don't get out of sync with the
     // database
     Services.prefs.savePrefFile(null);
     // Mark the previous theme as disabled. This won't cause recursion since
     // only enabled calls notifyAddonChanged.
     if (previousTheme)
       this.updateAddonDisabledState(previousTheme, true);
   },
   /**
    * Update the appDisabled property for all add-ons.
    */
   updateAddonAppDisabledStates: function XPI_updateAddonAppDisabledStates() {
     let addons = XPIDatabase.getAddons();
     addons.forEach(function(aAddon) {
       this.updateAddonDisabledState(aAddon);
     }, this);
   },
   /**
    * Update the repositoryAddon property for all add-ons.
    *
    * @param  aCallback
    *         Function to call when operation is complete.
    */
   updateAddonRepositoryData: function XPI_updateAddonRepositoryData(aCallback) {
     let self = this;
     XPIDatabase.getVisibleAddons(null, function UARD_getVisibleAddonsCallback(aAddons) {
       let pending = aAddons.length;
       logger.debug("updateAddonRepositoryData found " + pending + " visible add-ons");
       if (pending == 0) {
         aCallback();
         return;
       }
       function notifyComplete() {
         if (--pending == 0)
           aCallback();
       }
       for (let addon of aAddons) {
         AddonRepository.getCachedAddonByID(addon.id,
                                            function UARD_getCachedAddonCallback(aRepoAddon) {
           if (aRepoAddon) {
             logger.debug("updateAddonRepositoryData got info for " + addon.id);
             addon._repositoryAddon = aRepoAddon;
             addon.compatibilityOverrides = aRepoAddon.compatibilityOverrides;
             self.updateAddonDisabledState(addon);
           }
           notifyComplete();
         });
       };
     });
   },
   /**
    * When the previously selected theme is removed this method will be called
    * to enable the default theme.
    */
   enableDefaultTheme: function XPI_enableDefaultTheme() {
     logger.debug("Activating default theme");
     let addon = XPIDatabase.getVisibleAddonForInternalName(this.defaultSkin);
     if (addon) {
       if (addon.userDisabled) {
         this.updateAddonDisabledState(addon, false);
       }
       else if (!this.extensionsActive) {
         // During startup we may end up trying to enable the default theme when
         // the database thinks it is already enabled (see f.e. bug 638847). In
         // this case just force the theme preferences to be correct
         Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
                                    addon.internalName);
         this.currentSkin = this.selectedSkin = addon.internalName;
         Prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
         Prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
       }
       else {
         logger.warn("Attempting to activate an already active default theme");
       }
     }
     else {
       logger.warn("Unable to activate the default theme");
     }
   },
   onDebugConnectionChange: function(aEvent, aWhat, aConnection) {
     if (aWhat != "opened")
       return;
     for (let id of Object.keys(this.bootstrapScopes)) {
       aConnection.setAddonOptions(id, { global: this.bootstrapScopes[id] });
     }
   },
   /**
    * Notified when a preference we're interested in has changed.
    *
    * @see nsIObserver
    */
   observe: function XPI_observe(aSubject, aTopic, aData) {
     if (aTopic == NOTIFICATION_FLUSH_PERMISSIONS) {
       if (!aData || aData == XPI_PERMISSION) {
         this.importPermissions();
       }
       return;
     }
     if (aTopic == "nsPref:changed") {
       switch (aData) {
       case PREF_EM_MIN_COMPAT_APP_VERSION:
       case PREF_EM_MIN_COMPAT_PLATFORM_VERSION:
         this.minCompatibleAppVersion = Prefs.getCharPref(PREF_EM_MIN_COMPAT_APP_VERSION,
                                                          null);
         this.minCompatiblePlatformVersion = Prefs.getCharPref(PREF_EM_MIN_COMPAT_PLATFORM_VERSION,
                                                               null);
         this.updateAddonAppDisabledStates();
         break;
       }
     }
   },
   /**
    * Tests whether enabling an add-on will require a restart.
    *
    * @param  aAddon
    *         The add-on to test
    * @return true if the operation requires a restart
    */
   enableRequiresRestart: function XPI_enableRequiresRestart(aAddon) {
     // If the platform couldn't have activated extensions then we can make
     // changes without any restart.
     if (!this.extensionsActive)
       return false;
     // If the application is in safe mode then any change can be made without
     // restarting
     if (Services.appinfo.inSafeMode)
       return false;
     // Anything that is active is already enabled
     if (aAddon.active)
       return false;
     if (aAddon.type == "theme") {
       // If dynamic theme switching is enabled then switching themes does not
       // require a restart
       if (Prefs.getBoolPref(PREF_EM_DSS_ENABLED))
         return false;
       // If the theme is already the theme in use then no restart is necessary.
       // This covers the case where the default theme is in use but a
       // lightweight theme is considered active.
       return aAddon.internalName != this.currentSkin;
     }
     return !aAddon.bootstrap;
   },
   /**
    * Tests whether disabling an add-on will require a restart.
    *
    * @param  aAddon
    *         The add-on to test
    * @return true if the operation requires a restart
    */
   disableRequiresRestart: function XPI_disableRequiresRestart(aAddon) {
     // If the platform couldn't have activated up extensions then we can make
     // changes without any restart.
     if (!this.extensionsActive)
       return false;
     // If the application is in safe mode then any change can be made without
     // restarting
     if (Services.appinfo.inSafeMode)
       return false;
     // Anything that isn't active is already disabled
     if (!aAddon.active)
       return false;
     if (aAddon.type == "theme") {
       // If dynamic theme switching is enabled then switching themes does not
       // require a restart
       if (Prefs.getBoolPref(PREF_EM_DSS_ENABLED))
         return false;
       // Non-default themes always require a restart to disable since it will
       // be switching from one theme to another or to the default theme and a
       // lightweight theme.
       if (aAddon.internalName != this.defaultSkin)
         return true;
       // The default theme requires a restart to disable if we are in the
       // process of switching to a different theme. Note that this makes the
       // disabled flag of operationsRequiringRestart incorrect for the default
       // theme (it will be false most of the time). Bug 520124 would be required
       // to fix it. For the UI this isn't a problem since we never try to
       // disable or uninstall the default theme.
       return this.selectedSkin != this.currentSkin;
     }
     return !aAddon.bootstrap;
   },
   /**
    * Tests whether installing an add-on will require a restart.
    *
    * @param  aAddon
    *         The add-on to test
    * @return true if the operation requires a restart
    */
   installRequiresRestart: function XPI_installRequiresRestart(aAddon) {
     // If the platform couldn't have activated up extensions then we can make
     // changes without any restart.
     if (!this.extensionsActive)
       return false;
     // If the application is in safe mode then any change can be made without
     // restarting
     if (Services.appinfo.inSafeMode)
       return false;
     // Add-ons that are already installed don't require a restart to install.
     // This wouldn't normally be called for an already installed add-on (except
     // for forming the operationsRequiringRestart flags) so is really here as
     // a safety measure.
     if (aAddon.inDatabase)
       return false;
     // If we have an AddonInstall for this add-on then we can see if there is
     // an existing installed add-on with the same ID
     if ("_install" in aAddon && aAddon._install) {
       // If there is an existing installed add-on and uninstalling it would
       // require a restart then installing the update will also require a
       // restart
       let existingAddon = aAddon._install.existingAddon;
       if (existingAddon && this.uninstallRequiresRestart(existingAddon))
         return true;
     }
     // If the add-on is not going to be active after installation then it
     // doesn't require a restart to install.
     if (isAddonDisabled(aAddon))
       return false;
     // Themes will require a restart (even if dynamic switching is enabled due
     // to some caching issues) and non-bootstrapped add-ons will require a
     // restart
     return aAddon.type == "theme" || !aAddon.bootstrap;
   },
   /**
    * Tests whether uninstalling an add-on will require a restart.
    *
    * @param  aAddon
    *         The add-on to test
    * @return true if the operation requires a restart
    */
   uninstallRequiresRestart: function XPI_uninstallRequiresRestart(aAddon) {
     // If the platform couldn't have activated up extensions then we can make
     // changes without any restart.
     if (!this.extensionsActive)
       return false;
     // If the application is in safe mode then any change can be made without
     // restarting
     if (Services.appinfo.inSafeMode)
       return false;
     // If the add-on can be disabled without a restart then it can also be
     // uninstalled without a restart
     return this.disableRequiresRestart(aAddon);
   },
   /**
    * Loads a bootstrapped add-on's bootstrap.js into a sandbox and the reason
    * values as constants in the scope. This will also add information about the
    * add-on to the bootstrappedAddons dictionary and notify the crash reporter
    * that new add-ons have been loaded.
    *
    * @param  aId
    *         The add-on's ID
    * @param  aFile
    *         The nsIFile for the add-on
    * @param  aVersion
    *         The add-on's version
    * @param  aType
    *         The type for the add-on
    * @return a JavaScript scope
    */
   loadBootstrapScope: function XPI_loadBootstrapScope(aId, aFile, aVersion, aType) {
     // Mark the add-on as active for the crash reporter before loading
     this.bootstrappedAddons[aId] = {
       version: aVersion,
       type: aType,
       descriptor: aFile.persistentDescriptor
     };
     this.persistBootstrappedAddons();
     this.addAddonsToCrashReporter();
     // Locales only contain chrome and can't have bootstrap scripts
     if (aType == "locale") {
       this.bootstrapScopes[aId] = null;
       return;
     }
     logger.debug("Loading bootstrap scope from " + aFile.path);
     let principal = Cc["@mozilla.org/systemprincipal;1"].
                     createInstance(Ci.nsIPrincipal);
     if (!aFile.exists()) {
       this.bootstrapScopes[aId] =
         new Cu.Sandbox(principal, { sandboxName: aFile.path,
                                     wantGlobalProperties: ["indexedDB"],
                                     metadata: { addonID: aId } });
       logger.error("Attempted to load bootstrap scope from missing directory " + aFile.path);
       return;
     }
     let uri = getURIForResourceInFile(aFile, "bootstrap.js").spec;
     if (aType == "dictionary")
       uri = "resource://gre/modules/addons/SpellCheckDictionaryBootstrap.js"
     this.bootstrapScopes[aId] =
       new Cu.Sandbox(principal, { sandboxName: uri,
                                   wantGlobalProperties: ["indexedDB"],
                                   metadata: { addonID: aId, URI: uri } });
     let loader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                  createInstance(Ci.mozIJSSubScriptLoader);
     // Add a mapping for XPIProvider.mapURIToAddonID
     this._addURIMapping(aId, aFile);
     try {
       // Copy the reason values from the global object into the bootstrap scope.
       for (let name in BOOTSTRAP_REASONS)
         this.bootstrapScopes[aId][name] = BOOTSTRAP_REASONS[name];
       // Add other stuff that extensions want.
       const features = [ "Worker", "ChromeWorker" ];
       for (let feature of features)
         this.bootstrapScopes[aId][feature] = gGlobalScope[feature];
       // As we don't want our caller to control the JS version used for the
       // bootstrap file, we run loadSubScript within the context of the
       // sandbox with the latest JS version set explicitly.
       this.bootstrapScopes[aId].__SCRIPT_URI_SPEC__ = uri;
       Components.utils.evalInSandbox(
         "Components.classes['@mozilla.org/moz/jssubscript-loader;1'] \
                    .createInstance(Components.interfaces.mozIJSSubScriptLoader) \
                    .loadSubScript(__SCRIPT_URI_SPEC__);", this.bootstrapScopes[aId], "ECMAv5");
     }
     catch (e) {
       logger.warn("Error loading bootstrap.js for " + aId, e);
     }
     try {
       BrowserToolboxProcess.setAddonOptions(aId, { global: this.bootstrapScopes[aId] });
     }
     catch (e) {
       // BrowserToolboxProcess is not available in all applications
     }
   },
   /**
    * Unloads a bootstrap scope by dropping all references to it and then
    * updating the list of active add-ons with the crash reporter.
    *
    * @param  aId
    *         The add-on's ID
    */
   unloadBootstrapScope: function XPI_unloadBootstrapScope(aId) {
     delete this.bootstrapScopes[aId];
     delete this.bootstrappedAddons[aId];
     this.persistBootstrappedAddons();
     this.addAddonsToCrashReporter();
     try {
       BrowserToolboxProcess.setAddonOptions(aId, { global: null });
     }
     catch (e) {
       // BrowserToolboxProcess is not available in all applications
     }
   },
   /**
    * Calls a bootstrap method for an add-on.
    *
    * @param  aId
    *         The ID of the add-on
    * @param  aVersion
    *         The version of the add-on
    * @param  aType
    *         The type for the add-on
    * @param  aFile
    *         The nsIFile for the add-on
    * @param  aMethod
    *         The name of the bootstrap method to call
    * @param  aReason
    *         The reason flag to pass to the bootstrap's startup method
    * @param  aExtraParams
    *         An object of additional key/value pairs to pass to the method in
    *         the params argument
    */
   callBootstrapMethod: function XPI_callBootstrapMethod(aId, aVersion, aType, aFile,
                                                         aMethod, aReason, aExtraParams) {
     // Never call any bootstrap methods in safe mode
     if (Services.appinfo.inSafeMode)
       return;
     let timeStart = new Date();
     if (aMethod == "startup") {
       logger.debug("Registering manifest for " + aFile.path);
       Components.manager.addBootstrappedManifestLocation(aFile);
     }
     try {
       // Load the scope if it hasn't already been loaded
       if (!(aId in this.bootstrapScopes))
         this.loadBootstrapScope(aId, aFile, aVersion, aType);
       // Nothing to call for locales
       if (aType == "locale")
         return;
       if (!(aMethod in this.bootstrapScopes[aId])) {
         logger.warn("Add-on " + aId + " is missing bootstrap method " + aMethod);
         return;
       }
       let params = {
         id: aId,
         version: aVersion,
         installPath: aFile.clone(),
         resourceURI: getURIForResourceInFile(aFile, "")
       };
       if (aExtraParams) {
         for (let key in aExtraParams) {
           params[key] = aExtraParams[key];
         }
       }
       logger.debug("Calling bootstrap method " + aMethod + " on " + aId + " version " +
           aVersion);
       try {
         this.bootstrapScopes[aId][aMethod](params, aReason);
       }
       catch (e) {
         logger.warn("Exception running bootstrap method " + aMethod + " on " + aId, e);
       }
     }
     finally {
       if (aMethod == "shutdown" && aReason != BOOTSTRAP_REASONS.APP_SHUTDOWN) {
         logger.debug("Removing manifest for " + aFile.path);
         Components.manager.removeBootstrappedManifestLocation(aFile);
       }
       this.setTelemetry(aId, aMethod + "_MS", new Date() - timeStart);
     }
   },
   /**
    * Updates the disabled state for an add-on. Its appDisabled property will be
    * calculated and if the add-on is changed the database will be saved and
    * appropriate notifications will be sent out to the registered AddonListeners.
    *
    * @param  aAddon
    *         The DBAddonInternal to update
    * @param  aUserDisabled
    *         Value for the userDisabled property. If undefined the value will
    *         not change
    * @param  aSoftDisabled
    *         Value for the softDisabled property. If undefined the value will
    *         not change. If true this will force userDisabled to be true
    * @throws if addon is not a DBAddonInternal
    */
   updateAddonDisabledState: function XPI_updateAddonDisabledState(aAddon,
                                                                   aUserDisabled,
                                                                   aSoftDisabled) {
     if (!(aAddon.inDatabase))
       throw new Error("Can only update addon states for installed addons.");
     if (aUserDisabled !== undefined && aSoftDisabled !== undefined) {
       throw new Error("Cannot change userDisabled and softDisabled at the " +
                       "same time");
     }
     if (aUserDisabled === undefined) {
       aUserDisabled = aAddon.userDisabled;
     }
     else if (!aUserDisabled) {
       // If enabling the add-on then remove softDisabled
       aSoftDisabled = false;
     }
     // If not changing softDisabled or the add-on is already userDisabled then
     // use the existing value for softDisabled
     if (aSoftDisabled === undefined || aUserDisabled)
       aSoftDisabled = aAddon.softDisabled;
     let appDisabled = !isUsableAddon(aAddon);
     // No change means nothing to do here
     if (aAddon.userDisabled == aUserDisabled &&
         aAddon.appDisabled == appDisabled &&
         aAddon.softDisabled == aSoftDisabled)
       return;
     let wasDisabled = isAddonDisabled(aAddon);
     let isDisabled = aUserDisabled || aSoftDisabled || appDisabled;
     // If appDisabled changes but the result of isAddonDisabled() doesn't,
     // no onDisabling/onEnabling is sent - so send a onPropertyChanged.
     let appDisabledChanged = aAddon.appDisabled != appDisabled;
     // Update the properties in the database.
     // We never persist this for experiments because the disabled flags
     // are controlled by the Experiments Manager.
     if (aAddon.type != "experiment") {
       XPIDatabase.setAddonProperties(aAddon, {
         userDisabled: aUserDisabled,
         appDisabled: appDisabled,
         softDisabled: aSoftDisabled
       });
     }
     if (appDisabledChanged) {
       AddonManagerPrivate.callAddonListeners("onPropertyChanged",
                                             aAddon,
                                             ["appDisabled"]);
     }
     // If the add-on is not visible or the add-on is not changing state then
     // there is no need to do anything else
     if (!aAddon.visible || (wasDisabled == isDisabled))
       return;
     // Flag that active states in the database need to be updated on shutdown
     Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
     let wrapper = createWrapper(aAddon);
     // Have we just gone back to the current state?
     if (isDisabled != aAddon.active) {
       AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
     }
     else {
       if (isDisabled) {
         var needsRestart = this.disableRequiresRestart(aAddon);
         AddonManagerPrivate.callAddonListeners("onDisabling", wrapper,
                                                needsRestart);
       }
       else {
         needsRestart = this.enableRequiresRestart(aAddon);
         AddonManagerPrivate.callAddonListeners("onEnabling", wrapper,
                                                needsRestart);
       }
       if (!needsRestart) {
         XPIDatabase.updateAddonActive(aAddon, !isDisabled);
         if (isDisabled) {
           if (aAddon.bootstrap) {
             let file = aAddon._installLocation.getLocationForID(aAddon.id);
             this.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file, "shutdown",
                                      BOOTSTRAP_REASONS.ADDON_DISABLE);
             this.unloadBootstrapScope(aAddon.id);
           }
           AddonManagerPrivate.callAddonListeners("onDisabled", wrapper);
         }
         else {
           if (aAddon.bootstrap) {
             let file = aAddon._installLocation.getLocationForID(aAddon.id);
             this.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file, "startup",
                                      BOOTSTRAP_REASONS.ADDON_ENABLE);
           }
           AddonManagerPrivate.callAddonListeners("onEnabled", wrapper);
         }
       }
     }
     // Notify any other providers that a new theme has been enabled
     if (aAddon.type == "theme" && !isDisabled)
       AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, needsRestart);
   },
   /**
    * Uninstalls an add-on, immediately if possible or marks it as pending
    * uninstall if not.
    *
    * @param  aAddon
    *         The DBAddonInternal to uninstall
    * @throws if the addon cannot be uninstalled because it is in an install
    *         location that does not allow it
    */
   uninstallAddon: function XPI_uninstallAddon(aAddon) {
     if (!(aAddon.inDatabase))
       throw new Error("Can only uninstall installed addons.");
     if (aAddon._installLocation.locked)
       throw new Error("Cannot uninstall addons from locked install locations");
     if ("_hasResourceCache" in aAddon)
       aAddon._hasResourceCache = new Map();
     if (aAddon._updateCheck) {
       logger.debug("Cancel in-progress update check for " + aAddon.id);
       aAddon._updateCheck.cancel();
     }
     // Inactive add-ons don't require a restart to uninstall
     let requiresRestart = this.uninstallRequiresRestart(aAddon);
     if (requiresRestart) {
       // We create an empty directory in the staging directory to indicate that
       // an uninstall is necessary on next startup.
       let stage = aAddon._installLocation.getStagingDir();
       stage.append(aAddon.id);
       if (!stage.exists())
         stage.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
       XPIDatabase.setAddonProperties(aAddon, {
         pendingUninstall: true
       });
       Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
     }
     // If the add-on is not visible then there is no need to notify listeners.
     if (!aAddon.visible)
       return;
     let wrapper = createWrapper(aAddon);
     AddonManagerPrivate.callAddonListeners("onUninstalling", wrapper,
                                            requiresRestart);
     // Reveal the highest priority add-on with the same ID
     function revealAddon(aAddon) {
       XPIDatabase.makeAddonVisible(aAddon);
       let wrappedAddon = createWrapper(aAddon);
       AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false);
       if (!isAddonDisabled(aAddon) && !XPIProvider.enableRequiresRestart(aAddon)) {
         XPIDatabase.updateAddonActive(aAddon, true);
       }
       if (aAddon.bootstrap) {
         let file = aAddon._installLocation.getLocationForID(aAddon.id);
         XPIProvider.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file,
                                         "install", BOOTSTRAP_REASONS.ADDON_INSTALL);
         if (aAddon.active) {
           XPIProvider.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file,
                                           "startup", BOOTSTRAP_REASONS.ADDON_INSTALL);
         }
         else {
           XPIProvider.unloadBootstrapScope(aAddon.id);
         }
       }
       // We always send onInstalled even if a restart is required to enable
       // the revealed add-on
       AddonManagerPrivate.callAddonListeners("onInstalled", wrappedAddon);
     }
     function checkInstallLocation(aPos) {
       if (aPos < 0)
         return;
       let location = XPIProvider.installLocations[aPos];
       XPIDatabase.getAddonInLocation(aAddon.id, location.name,
         function checkInstallLocation_getAddonInLocation(aNewAddon) {
         if (aNewAddon)
           revealAddon(aNewAddon);
         else
           checkInstallLocation(aPos - 1);
       })
     }
     if (!requiresRestart) {
       if (aAddon.bootstrap) {
         let file = aAddon._installLocation.getLocationForID(aAddon.id);
         if (aAddon.active) {
           this.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file,
                                    "shutdown",
                                    BOOTSTRAP_REASONS.ADDON_UNINSTALL);
         }
         this.callBootstrapMethod(aAddon.id, aAddon.version, aAddon.type, file,
                                  "uninstall",
                                  BOOTSTRAP_REASONS.ADDON_UNINSTALL);
         this.unloadBootstrapScope(aAddon.id);
         flushStartupCache();
       }
       aAddon._installLocation.uninstallAddon(aAddon.id);
       XPIDatabase.removeAddonMetadata(aAddon);
       AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);
       checkInstallLocation(this.installLocations.length - 1);
     }
     // Notify any other providers that a new theme has been enabled
     if (aAddon.type == "theme" && aAddon.active)
       AddonManagerPrivate.notifyAddonChanged(null, aAddon.type, requiresRestart);
   },
   /**
    * Cancels the pending uninstall of an add-on.
    *
    * @param  aAddon
    *         The DBAddonInternal to cancel uninstall for
    */
   cancelUninstallAddon: function XPI_cancelUninstallAddon(aAddon) {
     if (!(aAddon.inDatabase))
       throw new Error("Can only cancel uninstall for installed addons.");
     aAddon._installLocation.cleanStagingDir([aAddon.id]);
     XPIDatabase.setAddonProperties(aAddon, {
       pendingUninstall: false
     });
     if (!aAddon.visible)
       return;
     Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
     // TODO hide hidden add-ons (bug 557710)
     let wrapper = createWrapper(aAddon);
     AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
     // Notify any other providers that this theme is now enabled again.
     if (aAddon.type == "theme" && aAddon.active)
       AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, false);
   }
 };
 function getHashStringForCrypto(aCrypto) {
   // return the two-digit hexadecimal code for a byte
   function toHexString(charCode)
     ("0" + charCode.toString(16)).slice(-2);
   // convert the binary hash data to a hex string.
   let binary = aCrypto.finish(false);
   return [toHexString(binary.charCodeAt(i)) for (i in binary)].join("").toLowerCase()
 }
 /**
  * Instantiates an AddonInstall.
  *
  * @param  aInstallLocation
  *         The install location the add-on will be installed into
  * @param  aUrl
  *         The nsIURL to get the add-on from. If this is an nsIFileURL then
  *         the add-on will not need to be downloaded
  * @param  aHash
  *         An optional hash for the add-on
  * @param  aReleaseNotesURI
  *         An optional nsIURI of release notes for the add-on
  * @param  aExistingAddon
  *         The add-on this install will update if known
  * @param  aLoadGroup
  *         The nsILoadGroup to associate any requests with
  * @throws if the url is the url of a local file and the hash does not match
  *         or the add-on does not contain an valid install manifest
  */
 function AddonInstall(aInstallLocation, aUrl, aHash, aReleaseNotesURI,
                       aExistingAddon, aLoadGroup) {
   this.wrapper = new AddonInstallWrapper(this);
   this.installLocation = aInstallLocation;
   this.sourceURI = aUrl;
   this.releaseNotesURI = aReleaseNotesURI;
   if (aHash) {
     let hashSplit = aHash.toLowerCase().split(":");
     this.originalHash = {
       algorithm: hashSplit[0],
       data: hashSplit[1]
     };
   }
   this.hash = this.originalHash;
   this.loadGroup = aLoadGroup;
   this.listeners = [];
   this.icons = {};
   this.existingAddon = aExistingAddon;
   this.error = 0;
   if (aLoadGroup)
     this.window = aLoadGroup.notificationCallbacks
                             .getInterface(Ci.nsIDOMWindow);
   else
     this.window = null;
   // Giving each instance of AddonInstall a reference to the logger.
   this.logger = logger;
 }
 AddonInstall.prototype = {
   installLocation: null,
   wrapper: null,
   stream: null,
   crypto: null,
   originalHash: null,
   hash: null,
   loadGroup: null,
   badCertHandler: null,
   listeners: null,
   restartDownload: false,
   name: null,
   type: null,
   version: null,
   icons: null,
   releaseNotesURI: null,
   sourceURI: null,
   file: null,
   ownsTempFile: false,
   certificate: null,
   certName: null,
   linkedInstalls: null,
   existingAddon: null,
   addon: null,
   state: null,
   error: null,
   progress: null,
   maxProgress: null,
   /**
    * Initialises this install to be a staged install waiting to be applied
    *
    * @param  aManifest
    *         The cached manifest for the staged install
    */
   initStagedInstall: function AI_initStagedInstall(aManifest) {
     this.name = aManifest.name;
     this.type = aManifest.type;
     this.version = aManifest.version;
     this.icons = aManifest.icons;
     this.releaseNotesURI = aManifest.releaseNotesURI ?
                            NetUtil.newURI(aManifest.releaseNotesURI) :
                            null
     this.sourceURI = aManifest.sourceURI ?
                      NetUtil.newURI(aManifest.sourceURI) :
                      null;
     this.file = null;
     this.addon = aManifest;
     this.state = AddonManager.STATE_INSTALLED;
     XPIProvider.installs.push(this);
   },
   /**
    * Initialises this install to be an install from a local file.
    *
    * @param  aCallback
    *         The callback to pass the initialised AddonInstall to
    */
   initLocalInstall: function AI_initLocalInstall(aCallback) {
     aCallback = makeSafe(aCallback);
     this.file = this.sourceURI.QueryInterface(Ci.nsIFileURL).file;
     if (!this.file.exists()) {
       logger.warn("XPI file " + this.file.path + " does not exist");
       this.state = AddonManager.STATE_DOWNLOAD_FAILED;
       this.error = AddonManager.ERROR_NETWORK_FAILURE;
       aCallback(this);
       return;
     }
     this.state = AddonManager.STATE_DOWNLOADED;
     this.progress = this.file.fileSize;
     this.maxProgress = this.file.fileSize;
     if (this.hash) {
       let crypto = Cc["@mozilla.org/security/hash;1"].
                    createInstance(Ci.nsICryptoHash);
       try {
         crypto.initWithString(this.hash.algorithm);
       }
       catch (e) {
         logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
         this.state = AddonManager.STATE_DOWNLOAD_FAILED;
         this.error = AddonManager.ERROR_INCORRECT_HASH;
         aCallback(this);
         return;
       }
       let fis = Cc["@mozilla.org/network/file-input-stream;1"].
                 createInstance(Ci.nsIFileInputStream);
       fis.init(this.file, -1, -1, false);
       crypto.updateFromStream(fis, this.file.fileSize);
       let calculatedHash = getHashStringForCrypto(crypto);
       if (calculatedHash != this.hash.data) {
         logger.warn("File hash (" + calculatedHash + ") did not match provided hash (" +
              this.hash.data + ")");
         this.state = AddonManager.STATE_DOWNLOAD_FAILED;
         this.error = AddonManager.ERROR_INCORRECT_HASH;
         aCallback(this);
         return;
       }
     }
     try {
       let self = this;
       this.loadManifest(function  initLocalInstall_loadManifest() {
         XPIDatabase.getVisibleAddonForID(self.addon.id, function initLocalInstall_getVisibleAddon(aAddon) {
           self.existingAddon = aAddon;
           if (aAddon)
             applyBlocklistChanges(aAddon, self.addon);
           self.addon.updateDate = Date.now();
           self.addon.installDate = aAddon ? aAddon.installDate : self.addon.updateDate;
           if (!self.addon.isCompatible) {
             // TODO Should we send some event here?
             self.state = AddonManager.STATE_CHECKING;
             new UpdateChecker(self.addon, {
               onUpdateFinished: function updateChecker_onUpdateFinished(aAddon) {
                 self.state = AddonManager.STATE_DOWNLOADED;
                 XPIProvider.installs.push(self);
                 AddonManagerPrivate.callInstallListeners("onNewInstall",
                                                          self.listeners,
                                                          self.wrapper);
                 aCallback(self);
               }
             }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
           }
           else {
             XPIProvider.installs.push(self);
             AddonManagerPrivate.callInstallListeners("onNewInstall",
                                                      self.listeners,
                                                      self.wrapper);
             aCallback(self);
           }
         });
       });
     }
     catch (e) {
       logger.warn("Invalid XPI", e);
       this.state = AddonManager.STATE_DOWNLOAD_FAILED;
       this.error = AddonManager.ERROR_CORRUPT_FILE;
       aCallback(this);
       return;
     }
   },
   /**
    * Initialises this install to be a download from a remote url.
    *
    * @param  aCallback
    *         The callback to pass the initialised AddonInstall to
    * @param  aName
    *         An optional name for the add-on
    * @param  aType
    *         An optional type for the add-on
    * @param  aIcons
    *         Optional icons for the add-on
    * @param  aVersion
    *         An optional version for the add-on
    */
   initAvailableDownload: function AI_initAvailableDownload(aName, aType, aIcons, aVersion, aCallback) {
     this.state = AddonManager.STATE_AVAILABLE;
     this.name = aName;
     this.type = aType;
     this.version = aVersion;
     this.icons = aIcons;
     this.progress = 0;
     this.maxProgress = -1;
     XPIProvider.installs.push(this);
     AddonManagerPrivate.callInstallListeners("onNewInstall", this.listeners,
                                              this.wrapper);
     makeSafe(aCallback)(this);
   },
   /**
    * Starts installation of this add-on from whatever state it is currently at
    * if possible.
    *
    * @throws if installation cannot proceed from the current state
    */
   install: function AI_install() {
     switch (this.state) {
     case AddonManager.STATE_AVAILABLE:
       this.startDownload();
       break;
     case AddonManager.STATE_DOWNLOADED:
       this.startInstall();
       break;
     case AddonManager.STATE_DOWNLOAD_FAILED:
     case AddonManager.STATE_INSTALL_FAILED:
     case AddonManager.STATE_CANCELLED:
       this.removeTemporaryFile();
       this.state = AddonManager.STATE_AVAILABLE;
       this.error = 0;
       this.progress = 0;
       this.maxProgress = -1;
       this.hash = this.originalHash;
       XPIProvider.installs.push(this);
       this.startDownload();
       break;
     case AddonManager.STATE_DOWNLOADING:
     case AddonManager.STATE_CHECKING:
     case AddonManager.STATE_INSTALLING:
       // Installation is already running
       return;
     default:
       throw new Error("Cannot start installing from this state");
     }
   },
   /**
    * Cancels installation of this add-on.
    *
    * @throws if installation cannot be cancelled from the current state
    */
   cancel: function AI_cancel() {
     switch (this.state) {
     case AddonManager.STATE_DOWNLOADING:
       if (this.channel)
         this.channel.cancel(Cr.NS_BINDING_ABORTED);
     case AddonManager.STATE_AVAILABLE:
     case AddonManager.STATE_DOWNLOADED:
       logger.debug("Cancelling download of " + this.sourceURI.spec);
       this.state = AddonManager.STATE_CANCELLED;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
                                                this.listeners, this.wrapper);
       this.removeTemporaryFile();
       break;
     case AddonManager.STATE_INSTALLED:
       logger.debug("Cancelling install of " + this.addon.id);
       let xpi = this.installLocation.getStagingDir();
       xpi.append(this.addon.id + ".xpi");
       flushJarCache(xpi);
       this.installLocation.cleanStagingDir([this.addon.id, this.addon.id + ".xpi",
                                             this.addon.id + ".json"]);
       this.state = AddonManager.STATE_CANCELLED;
       XPIProvider.removeActiveInstall(this);
       if (this.existingAddon) {
         delete this.existingAddon.pendingUpgrade;
         this.existingAddon.pendingUpgrade = null;
       }
       AddonManagerPrivate.callAddonListeners("onOperationCancelled", createWrapper(this.addon));
       AddonManagerPrivate.callInstallListeners("onInstallCancelled",
                                                this.listeners, this.wrapper);
       break;
     default:
       throw new Error("Cannot cancel install of " + this.sourceURI.spec +
                       " from this state (" + this.state + ")");
     }
   },
   /**
    * Adds an InstallListener for this instance if the listener is not already
    * registered.
    *
    * @param  aListener
    *         The InstallListener to add
    */
   addListener: function AI_addListener(aListener) {
     if (!this.listeners.some(function addListener_matchListener(i) { return i == aListener; }))
       this.listeners.push(aListener);
   },
   /**
    * Removes an InstallListener for this instance if it is registered.
    *
    * @param  aListener
    *         The InstallListener to remove
    */
   removeListener: function AI_removeListener(aListener) {
     this.listeners = this.listeners.filter(function removeListener_filterListener(i) {
       return i != aListener;
     });
   },
   /**
    * Removes the temporary file owned by this AddonInstall if there is one.
    */
   removeTemporaryFile: function AI_removeTemporaryFile() {
     // Only proceed if this AddonInstall owns its XPI file
     if (!this.ownsTempFile) {
       this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " does not own temp file");
       return;
     }
     try {
       this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " removing temp file " +
           this.file.path);
       this.file.remove(true);
       this.ownsTempFile = false;
     }
     catch (e) {
       this.logger.warn("Failed to remove temporary file " + this.file.path + " for addon " +
           this.sourceURI.spec,
           e);
     }
   },
   /**
    * Updates the sourceURI and releaseNotesURI values on the Addon being
    * installed by this AddonInstall instance.
    */
   updateAddonURIs: function AI_updateAddonURIs() {
     this.addon.sourceURI = this.sourceURI.spec;
     if (this.releaseNotesURI)
       this.addon.releaseNotesURI = this.releaseNotesURI.spec;
   },
   /**
    * Loads add-on manifests from a multi-package XPI file. Each of the
    * XPI and JAR files contained in the XPI will be extracted. Any that
    * do not contain valid add-ons will be ignored. The first valid add-on will
    * be installed by this AddonInstall instance, the rest will have new
    * AddonInstall instances created for them.
    *
    * @param  aZipReader
    *         An open nsIZipReader for the multi-package XPI's files. This will
    *         be closed before this method returns.
    * @param  aCallback
    *         A function to call when all of the add-on manifests have been
    *         loaded. Because this loadMultipackageManifests is an internal API
    *         we don't exception-wrap this callback
    */
   _loadMultipackageManifests: function AI_loadMultipackageManifests(aZipReader,
                                                                    aCallback) {
     let files = [];
     let entries = aZipReader.findEntries("(*.[Xx][Pp][Ii]|*.[Jj][Aa][Rr])");
     while (entries.hasMore()) {
       let entryName = entries.getNext();
       var target = getTemporaryFile();
       try {
         aZipReader.extract(entryName, target);
         files.push(target);
       }
       catch (e) {
         logger.warn("Failed to extract " + entryName + " from multi-package " +
              "XPI", e);
         target.remove(false);
       }
     }
     aZipReader.close();
     if (files.length == 0) {
       throw new Error("Multi-package XPI does not contain any packages " +
                       "to install");
     }
     let addon = null;
     // Find the first file that has a valid install manifest and use it for
     // the add-on that this AddonInstall instance will install.
     while (files.length > 0) {
       this.removeTemporaryFile();
       this.file = files.shift();
       this.ownsTempFile = true;
       try {
         addon = loadManifestFromZipFile(this.file);
         break;
       }
       catch (e) {
         logger.warn(this.file.leafName + " cannot be installed from multi-package " +
              "XPI", e);
       }
     }
     if (!addon) {
       // No valid add-on was found
       aCallback();
       return;
     }
     this.addon = addon;
     this.updateAddonURIs();
     this.addon._install = this;
     this.name = this.addon.selectedLocale.name;
     this.type = this.addon.type;
     this.version = this.addon.version;
     // Setting the iconURL to something inside the XPI locks the XPI and
     // makes it impossible to delete on Windows.
     //let newIcon = createWrapper(this.addon).iconURL;
     //if (newIcon)
     //  this.iconURL = newIcon;
     // Create new AddonInstall instances for every remaining file
     if (files.length > 0) {
       this.linkedInstalls = [];
       let count = 0;
       let self = this;
       files.forEach(function(file) {
         AddonInstall.createInstall(function loadMultipackageManifests_createInstall(aInstall) {
           // Ignore bad add-ons (createInstall will have logged the error)
           if (aInstall.state == AddonManager.STATE_DOWNLOAD_FAILED) {
             // Manually remove the temporary file
             file.remove(true);
           }
           else {
             // Make the new install own its temporary file
             aInstall.ownsTempFile = true;
             self.linkedInstalls.push(aInstall)
             aInstall.sourceURI = self.sourceURI;
             aInstall.releaseNotesURI = self.releaseNotesURI;
             aInstall.updateAddonURIs();
           }
           count++;
           if (count == files.length)
             aCallback();
         }, file);
       }, this);
     }
     else {
       aCallback();
     }
   },
   /**
    * Called after the add-on is a local file and the signature and install
    * manifest can be read.
    *
    * @param  aCallback
    *         A function to call when the manifest has been loaded
    * @throws if the add-on does not contain a valid install manifest or the
    *         XPI is incorrectly signed
    */
   loadManifest: function AI_loadManifest(aCallback) {
     aCallback = makeSafe(aCallback);
     let self = this;
     function addRepositoryData(aAddon) {
       // Try to load from the existing cache first
       AddonRepository.getCachedAddonByID(aAddon.id, function loadManifest_getCachedAddonByID(aRepoAddon) {
         if (aRepoAddon) {
           aAddon._repositoryAddon = aRepoAddon;
           self.name = self.name || aAddon._repositoryAddon.name;
           aAddon.compatibilityOverrides = aRepoAddon.compatibilityOverrides;
           aAddon.appDisabled = !isUsableAddon(aAddon);
           aCallback();
           return;
         }
         // It wasn't there so try to re-download it
         AddonRepository.cacheAddons([aAddon.id], function loadManifest_cacheAddons() {
           AddonRepository.getCachedAddonByID(aAddon.id, function loadManifest_getCachedAddonByID(aRepoAddon) {
             aAddon._repositoryAddon = aRepoAddon;
             self.name = self.name || aAddon._repositoryAddon.name;
             aAddon.compatibilityOverrides = aRepoAddon ?
                                               aRepoAddon.compatibilityOverrides :
                                               null;
             aAddon.appDisabled = !isUsableAddon(aAddon);
             aCallback();
           });
         });
       });
     }
     let zipreader = Cc["@mozilla.org/libjar/zip-reader;1"].
                     createInstance(Ci.nsIZipReader);
     try {
       zipreader.open(this.file);
     }
     catch (e) {
       zipreader.close();
       throw e;
     }
     let principal = zipreader.getCertificatePrincipal(null);
     if (principal && principal.hasCertificate) {
       logger.debug("Verifying XPI signature");
       if (verifyZipSigning(zipreader, principal)) {
         let x509 = principal.certificate;
         if (x509 instanceof Ci.nsIX509Cert)
           this.certificate = x509;
         if (this.certificate && this.certificate.commonName.length > 0)
           this.certName = this.certificate.commonName;
         else
           this.certName = principal.prettyName;
       }
       else {
         zipreader.close();
         throw new Error("XPI is incorrectly signed");
       }
     }
     try {
       this.addon = loadManifestFromZipReader(zipreader);
     }
     catch (e) {
       zipreader.close();
       throw e;
     }
     if (this.addon.type == "multipackage") {
       this._loadMultipackageManifests(zipreader, function loadManifest_loadMultipackageManifests() {
         addRepositoryData(self.addon);
       });
       return;
     }
     zipreader.close();
     this.updateAddonURIs();
     this.addon._install = this;
     this.name = this.addon.selectedLocale.name;
     this.type = this.addon.type;
     this.version = this.addon.version;
     // Setting the iconURL to something inside the XPI locks the XPI and
     // makes it impossible to delete on Windows.
     //let newIcon = createWrapper(this.addon).iconURL;
     //if (newIcon)
     //  this.iconURL = newIcon;
     addRepositoryData(this.addon);
   },
   observe: function AI_observe(aSubject, aTopic, aData) {
     // Network is going offline
     this.cancel();
   },
   /**
    * Starts downloading the add-on's XPI file.
    */
   startDownload: function AI_startDownload() {
     this.state = AddonManager.STATE_DOWNLOADING;
     if (!AddonManagerPrivate.callInstallListeners("onDownloadStarted",
                                                   this.listeners, this.wrapper)) {
       logger.debug("onDownloadStarted listeners cancelled installation of addon " + this.sourceURI.spec);
       this.state = AddonManager.STATE_CANCELLED;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
                                                this.listeners, this.wrapper)
       return;
     }
     // If a listener changed our state then do not proceed with the download
     if (this.state != AddonManager.STATE_DOWNLOADING)
       return;
     if (this.channel) {
       // A previous download attempt hasn't finished cleaning up yet, signal
       // that it should restart when complete
       logger.debug("Waiting for previous download to complete");
       this.restartDownload = true;
       return;
     }
     this.openChannel();
   },
   openChannel: function AI_openChannel() {
     this.restartDownload = false;
     try {
       this.file = getTemporaryFile();
       this.ownsTempFile = true;
       this.stream = Cc["@mozilla.org/network/file-output-stream;1"].
                     createInstance(Ci.nsIFileOutputStream);
       this.stream.init(this.file, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
                        FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE, 0);
     }
     catch (e) {
       logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
       this.state = AddonManager.STATE_DOWNLOAD_FAILED;
       this.error = AddonManager.ERROR_FILE_ACCESS;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callInstallListeners("onDownloadFailed",
                                                this.listeners, this.wrapper);
       return;
     }
     let listener = Cc["@mozilla.org/network/stream-listener-tee;1"].
                    createInstance(Ci.nsIStreamListenerTee);
     listener.init(this, this.stream);
     try {
       Components.utils.import("resource://gre/modules/CertUtils.jsm");
       let requireBuiltIn = Prefs.getBoolPref(PREF_INSTALL_REQUIREBUILTINCERTS, true);
       this.badCertHandler = new BadCertHandler(!requireBuiltIn);
       this.channel = NetUtil.newChannel(this.sourceURI);
       this.channel.notificationCallbacks = this;
       if (this.channel instanceof Ci.nsIHttpChannelInternal)
         this.channel.forceAllowThirdPartyCookie = true;
       this.channel.asyncOpen(listener, null);
       Services.obs.addObserver(this, "network:offline-about-to-go-offline", false);
     }
     catch (e) {
       logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
       this.state = AddonManager.STATE_DOWNLOAD_FAILED;
       this.error = AddonManager.ERROR_NETWORK_FAILURE;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callInstallListeners("onDownloadFailed",
                                                this.listeners, this.wrapper);
     }
   },
   /**
    * Update the crypto hasher with the new data and call the progress listeners.
    *
    * @see nsIStreamListener
    */
   onDataAvailable: function AI_onDataAvailable(aRequest, aContext, aInputstream,
                                                aOffset, aCount) {
     this.crypto.updateFromStream(aInputstream, aCount);
     this.progress += aCount;
     if (!AddonManagerPrivate.callInstallListeners("onDownloadProgress",
                                                   this.listeners, this.wrapper)) {
       // TODO cancel the download and make it available again (bug 553024)
     }
   },
   /**
    * Check the redirect response for a hash of the target XPI and verify that
    * we don't end up on an insecure channel.
    *
    * @see nsIChannelEventSink
    */
   asyncOnChannelRedirect: function AI_asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback) {
     if (!this.hash && aOldChannel.originalURI.schemeIs("https") &&
         aOldChannel instanceof Ci.nsIHttpChannel) {
       try {
         let hashStr = aOldChannel.getResponseHeader("X-Target-Digest");
         let hashSplit = hashStr.toLowerCase().split(":");
         this.hash = {
           algorithm: hashSplit[0],
           data: hashSplit[1]
         };
       }
       catch (e) {
       }
     }
     // Verify that we don't end up on an insecure channel if we haven't got a
     // hash to verify with (see bug 537761 for discussion)
     if (!this.hash)
       this.badCertHandler.asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback);
     else
       aCallback.onRedirectVerifyCallback(Cr.NS_OK);
     this.channel = aNewChannel;
   },
   /**
    * This is the first chance to get at real headers on the channel.
    *
    * @see nsIStreamListener
    */
   onStartRequest: function AI_onStartRequest(aRequest, aContext) {
     this.crypto = Cc["@mozilla.org/security/hash;1"].
                   createInstance(Ci.nsICryptoHash);
     if (this.hash) {
       try {
         this.crypto.initWithString(this.hash.algorithm);
       }
       catch (e) {
         logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
         this.state = AddonManager.STATE_DOWNLOAD_FAILED;
         this.error = AddonManager.ERROR_INCORRECT_HASH;
         XPIProvider.removeActiveInstall(this);
         AddonManagerPrivate.callInstallListeners("onDownloadFailed",
                                                  this.listeners, this.wrapper);
         aRequest.cancel(Cr.NS_BINDING_ABORTED);
         return;
       }
     }
     else {
       // We always need something to consume data from the inputstream passed
       // to onDataAvailable so just create a dummy cryptohasher to do that.
       this.crypto.initWithString("sha1");
     }
     this.progress = 0;
     if (aRequest instanceof Ci.nsIChannel) {
       try {
         this.maxProgress = aRequest.contentLength;
       }
       catch (e) {
       }
       logger.debug("Download started for " + this.sourceURI.spec + " to file " +
           this.file.path);
     }
   },
   /**
    * The download is complete.
    *
    * @see nsIStreamListener
    */
   onStopRequest: function AI_onStopRequest(aRequest, aContext, aStatus) {
     this.stream.close();
     this.channel = null;
     this.badCerthandler = null;
     Services.obs.removeObserver(this, "network:offline-about-to-go-offline");
     // If the download was cancelled then all events will have already been sent
     if (aStatus == Cr.NS_BINDING_ABORTED) {
       this.removeTemporaryFile();
       if (this.restartDownload)
         this.openChannel();
       return;
     }
     logger.debug("Download of " + this.sourceURI.spec + " completed.");
     if (Components.isSuccessCode(aStatus)) {
       if (!(aRequest instanceof Ci.nsIHttpChannel) || aRequest.requestSucceeded) {
         if (!this.hash && (aRequest instanceof Ci.nsIChannel)) {
           try {
             checkCert(aRequest,
                       !Prefs.getBoolPref(PREF_INSTALL_REQUIREBUILTINCERTS, true));
           }
           catch (e) {
             this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, e);
             return;
           }
         }
         // convert the binary hash data to a hex string.
         let calculatedHash = getHashStringForCrypto(this.crypto);
         this.crypto = null;
         if (this.hash && calculatedHash != this.hash.data) {
           this.downloadFailed(AddonManager.ERROR_INCORRECT_HASH,
                               "Downloaded file hash (" + calculatedHash +
                               ") did not match provided hash (" + this.hash.data + ")");
           return;
         }
         try {
           let self = this;
           this.loadManifest(function onStopRequest_loadManifest() {
             if (self.addon.isCompatible) {
               self.downloadCompleted();
             }
             else {
               // TODO Should we send some event here (bug 557716)?
               self.state = AddonManager.STATE_CHECKING;
               new UpdateChecker(self.addon, {
                 onUpdateFinished: function onStopRequest_onUpdateFinished(aAddon) {
                   self.downloadCompleted();
                 }
               }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
             }
           });
         }
         catch (e) {
           this.downloadFailed(AddonManager.ERROR_CORRUPT_FILE, e);
         }
       }
       else {
         if (aRequest instanceof Ci.nsIHttpChannel)
           this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE,
                               aRequest.responseStatus + " " +
                               aRequest.responseStatusText);
         else
           this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
       }
     }
     else {
       this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
     }
   },
   /**
    * Notify listeners that the download failed.
    *
    * @param  aReason
    *         Something to log about the failure
    * @param  error
    *         The error code to pass to the listeners
    */
   downloadFailed: function AI_downloadFailed(aReason, aError) {
     logger.warn("Download of " + this.sourceURI.spec + " failed", aError);
     this.state = AddonManager.STATE_DOWNLOAD_FAILED;
     this.error = aReason;
     XPIProvider.removeActiveInstall(this);
     AddonManagerPrivate.callInstallListeners("onDownloadFailed", this.listeners,
                                              this.wrapper);
     // If the listener hasn't restarted the download then remove any temporary
     // file
     if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) {
       logger.debug("downloadFailed: removing temp file for " + this.sourceURI.spec);
       this.removeTemporaryFile();
     }
     else
       logger.debug("downloadFailed: listener changed AddonInstall state for " +
           this.sourceURI.spec + " to " + this.state);
   },
   /**
    * Notify listeners that the download completed.
    */
   downloadCompleted: function AI_downloadCompleted() {
     let self = this;
     XPIDatabase.getVisibleAddonForID(this.addon.id, function downloadCompleted_getVisibleAddonForID(aAddon) {
       if (aAddon)
         self.existingAddon = aAddon;
       self.state = AddonManager.STATE_DOWNLOADED;
       self.addon.updateDate = Date.now();
       if (self.existingAddon) {
         self.addon.existingAddonID = self.existingAddon.id;
         self.addon.installDate = self.existingAddon.installDate;
         applyBlocklistChanges(self.existingAddon, self.addon);
       }
       else {
         self.addon.installDate = self.addon.updateDate;
       }
       if (AddonManagerPrivate.callInstallListeners("onDownloadEnded",
                                                    self.listeners,
                                                    self.wrapper)) {
         // If a listener changed our state then do not proceed with the install
         if (self.state != AddonManager.STATE_DOWNLOADED)
           return;
         self.install();
         if (self.linkedInstalls) {
           self.linkedInstalls.forEach(function(aInstall) {
             aInstall.install();
           });
         }
       }
     });
   },
   // TODO This relies on the assumption that we are always installing into the
   // highest priority install location so the resulting add-on will be visible
   // overriding any existing copy in another install location (bug 557710).
   /**
    * Installs the add-on into the install location.
    */
   startInstall: function AI_startInstall() {
     this.state = AddonManager.STATE_INSTALLING;
     if (!AddonManagerPrivate.callInstallListeners("onInstallStarted",
                                                   this.listeners, this.wrapper)) {
       this.state = AddonManager.STATE_DOWNLOADED;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callInstallListeners("onInstallCancelled",
                                                this.listeners, this.wrapper)
       return;
     }
     // Find and cancel any pending installs for the same add-on in the same
     // install location
     for (let aInstall of XPIProvider.installs) {
       if (aInstall.state == AddonManager.STATE_INSTALLED &&
           aInstall.installLocation == this.installLocation &&
           aInstall.addon.id == this.addon.id) {
         logger.debug("Cancelling previous pending install of " + aInstall.addon.id);
         aInstall.cancel();
       }
     }
     let isUpgrade = this.existingAddon &&
                     this.existingAddon._installLocation == this.installLocation;
     let requiresRestart = XPIProvider.installRequiresRestart(this.addon);
     logger.debug("Starting install of " + this.addon.id + " from " + this.sourceURI.spec);
     AddonManagerPrivate.callAddonListeners("onInstalling",
                                            createWrapper(this.addon),
                                            requiresRestart);
     let stagingDir = this.installLocation.getStagingDir();
     let stagedAddon = stagingDir.clone();
     Task.spawn((function() {
       let installedUnpacked = 0;
       yield this.installLocation.requestStagingDir();
       // First stage the file regardless of whether restarting is necessary
       if (this.addon.unpack || Prefs.getBoolPref(PREF_XPI_UNPACK, false)) {
         logger.debug("Addon " + this.addon.id + " will be installed as " +
             "an unpacked directory");
         stagedAddon.append(this.addon.id);
         yield removeAsync(stagedAddon);
         yield OS.File.makeDir(stagedAddon.path);
         yield ZipUtils.extractFilesAsync(this.file, stagedAddon);
         installedUnpacked = 1;
       }
       else {
         logger.debug("Addon " + this.addon.id + " will be installed as " +
             "a packed xpi");
         stagedAddon.append(this.addon.id + ".xpi");
         yield removeAsync(stagedAddon);
         yield OS.File.copy(this.file.path, stagedAddon.path);
       }
       if (requiresRestart) {
         // Point the add-on to its extracted files as the xpi may get deleted
         this.addon._sourceBundle = stagedAddon;
         // Cache the AddonInternal as it may have updated compatibility info
         let stagedJSON = stagedAddon.clone();
         stagedJSON.leafName = this.addon.id + ".json";
         if (stagedJSON.exists())
           stagedJSON.remove(true);
         let stream = Cc["@mozilla.org/network/file-output-stream;1"].
                      createInstance(Ci.nsIFileOutputStream);
         let converter = Cc["@mozilla.org/intl/converter-output-stream;1"].
                         createInstance(Ci.nsIConverterOutputStream);
         try {
           stream.init(stagedJSON, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
                                   FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE,
 );
           converter.init(stream, "UTF-8", 0, 0x0000);
           converter.writeString(JSON.stringify(this.addon));
         }
         finally {
           converter.close();
           stream.close();
         }
         logger.debug("Staged install of " + this.addon.id + " from " + this.sourceURI.spec + " ready; waiting for restart.");
         this.state = AddonManager.STATE_INSTALLED;
         if (isUpgrade) {
           delete this.existingAddon.pendingUpgrade;
           this.existingAddon.pendingUpgrade = this.addon;
         }
         AddonManagerPrivate.callInstallListeners("onInstallEnded",
                                                  this.listeners, this.wrapper,
                                                  createWrapper(this.addon));
       }
       else {
         // The install is completed so it should be removed from the active list
         XPIProvider.removeActiveInstall(this);
         // TODO We can probably reduce the number of DB operations going on here
         // We probably also want to support rolling back failed upgrades etc.
         // See bug 553015.
         // Deactivate and remove the old add-on as necessary
         let reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
         if (this.existingAddon) {
           if (Services.vc.compare(this.existingAddon.version, this.addon.version) < 0)
             reason = BOOTSTRAP_REASONS.ADDON_UPGRADE;
           else
             reason = BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
           if (this.existingAddon.bootstrap) {
             let file = this.existingAddon._installLocation
                            .getLocationForID(this.existingAddon.id);
             if (this.existingAddon.active) {
               XPIProvider.callBootstrapMethod(this.existingAddon.id,
                                               this.existingAddon.version,
                                               this.existingAddon.type, file,
                                               "shutdown", reason,
                                               { newVersion: this.addon.version });
             }
             XPIProvider.callBootstrapMethod(this.existingAddon.id,
                                             this.existingAddon.version,
                                             this.existingAddon.type, file,
                                             "uninstall", reason,
                                             { newVersion: this.addon.version });
             XPIProvider.unloadBootstrapScope(this.existingAddon.id);
             flushStartupCache();
           }
           if (!isUpgrade && this.existingAddon.active) {
             XPIDatabase.updateAddonActive(this.existingAddon, false);
           }
         }
         // Install the new add-on into its final location
         let existingAddonID = this.existingAddon ? this.existingAddon.id : null;
         let file = this.installLocation.installAddon(this.addon.id, stagedAddon,
                                                      existingAddonID);
         // Update the metadata in the database
         this.addon._sourceBundle = file;
         this.addon._installLocation = this.installLocation;
         let scanStarted = Date.now();
         let [, mTime, scanItems] = recursiveLastModifiedTime(file);
         let scanTime = Date.now() - scanStarted;
         this.addon.updateDate = mTime;
         this.addon.visible = true;
         if (isUpgrade) {
           this.addon =  XPIDatabase.updateAddonMetadata(this.existingAddon, this.addon,
                                                         file.persistentDescriptor);
         }
         else {
           this.addon.installDate = this.addon.updateDate;
           this.addon.active = (this.addon.visible && !isAddonDisabled(this.addon))
           this.addon = XPIDatabase.addAddonMetadata(this.addon, file.persistentDescriptor);
         }
         let extraParams = {};
         if (this.existingAddon) {
           extraParams.oldVersion = this.existingAddon.version;
         }
         if (this.addon.bootstrap) {
           XPIProvider.callBootstrapMethod(this.addon.id, this.addon.version,
                                           this.addon.type, file, "install",
                                           reason, extraParams);
         }
         AddonManagerPrivate.callAddonListeners("onInstalled",
                                                createWrapper(this.addon));
         logger.debug("Install of " + this.sourceURI.spec + " completed.");
         this.state = AddonManager.STATE_INSTALLED;
         AddonManagerPrivate.callInstallListeners("onInstallEnded",
                                                  this.listeners, this.wrapper,
                                                  createWrapper(this.addon));
         if (this.addon.bootstrap) {
           if (this.addon.active) {
             XPIProvider.callBootstrapMethod(this.addon.id, this.addon.version,
                                             this.addon.type, file, "startup",
                                             reason, extraParams);
           }
           else {
             // XXX this makes it dangerous to do some things in onInstallEnded
             // listeners because important cleanup hasn't been done yet
             XPIProvider.unloadBootstrapScope(this.addon.id);
           }
         }
         XPIProvider.setTelemetry(this.addon.id, "unpacked", installedUnpacked);
         XPIProvider.setTelemetry(this.addon.id, "location", this.installLocation.name);
         XPIProvider.setTelemetry(this.addon.id, "scan_MS", scanTime);
         XPIProvider.setTelemetry(this.addon.id, "scan_items", scanItems);
         let loc = this.addon.defaultLocale;
         if (loc) {
           XPIProvider.setTelemetry(this.addon.id, "name", loc.name);
           XPIProvider.setTelemetry(this.addon.id, "creator", loc.creator);
         }
       }
     }).bind(this)).then(null, (e) => {
       logger.warn("Failed to install " + this.file.path + " from " + this.sourceURI.spec, e);
       if (stagedAddon.exists())
         recursiveRemove(stagedAddon);
       this.state = AddonManager.STATE_INSTALL_FAILED;
       this.error = AddonManager.ERROR_FILE_ACCESS;
       XPIProvider.removeActiveInstall(this);
       AddonManagerPrivate.callAddonListeners("onOperationCancelled",
                                              createWrapper(this.addon));
       AddonManagerPrivate.callInstallListeners("onInstallFailed",
                                                this.listeners,
                                                this.wrapper);
     }).then(() => {
       this.removeTemporaryFile();
       return this.installLocation.releaseStagingDir();
     });
   },
   getInterface: function AI_getInterface(iid) {
     if (iid.equals(Ci.nsIAuthPrompt2)) {
       var factory = Cc["@mozilla.org/prompter;1"].
                     getService(Ci.nsIPromptFactory);
       return factory.getPrompt(this.window, Ci.nsIAuthPrompt);
     }
     else if (iid.equals(Ci.nsIChannelEventSink)) {
       return this;
     }
     return this.badCertHandler.getInterface(iid);
   }
 }
 /**
  * Creates a new AddonInstall for an already staged install. Used when
  * installing the staged install failed for some reason.
  *
  * @param  aDir
  *         The directory holding the staged install
  * @param  aManifest
  *         The cached manifest for the install
  */
 AddonInstall.createStagedInstall = function AI_createStagedInstall(aInstallLocation, aDir, aManifest) {
   let url = Services.io.newFileURI(aDir);
   let install = new AddonInstall(aInstallLocation, aDir);
   install.initStagedInstall(aManifest);
 };
 /**
  * Creates a new AddonInstall to install an add-on from a local file. Installs
  * always go into the profile install location.
  *
  * @param  aCallback
  *         The callback to pass the new AddonInstall to
  * @param  aFile
  *         The file to install
  */
 AddonInstall.createInstall = function AI_createInstall(aCallback, aFile) {
   let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
   let url = Services.io.newFileURI(aFile);
   try {
     let install = new AddonInstall(location, url);
     install.initLocalInstall(aCallback);
   }
   catch(e) {
     logger.error("Error creating install", e);
     makeSafe(aCallback)(null);
   }
 };
 /**
  * Creates a new AddonInstall to download and install a URL.
  *
  * @param  aCallback
  *         The callback to pass the new AddonInstall to
  * @param  aUri
  *         The URI to download
  * @param  aHash
  *         A hash for the add-on
  * @param  aName
  *         A name for the add-on
  * @param  aIcons
  *         An icon URLs for the add-on
  * @param  aVersion
  *         A version for the add-on
  * @param  aLoadGroup
  *         An nsILoadGroup to associate the download with
  */
 AddonInstall.createDownload = function AI_createDownload(aCallback, aUri, aHash, aName, aIcons,
                                        aVersion, aLoadGroup) {
   let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
   let url = NetUtil.newURI(aUri);
   let install = new AddonInstall(location, url, aHash, null, null, aLoadGroup);
   if (url instanceof Ci.nsIFileURL)
     install.initLocalInstall(aCallback);
   else
     install.initAvailableDownload(aName, null, aIcons, aVersion, aCallback);
 };
 /**
  * Creates a new AddonInstall for an update.
  *
  * @param  aCallback
  *         The callback to pass the new AddonInstall to
  * @param  aAddon
  *         The add-on being updated
  * @param  aUpdate
  *         The metadata about the new version from the update manifest
  */
 AddonInstall.createUpdate = function AI_createUpdate(aCallback, aAddon, aUpdate) {
   let url = NetUtil.newURI(aUpdate.updateURL);
   let releaseNotesURI = null;
   try {
     if (aUpdate.updateInfoURL)
       releaseNotesURI = NetUtil.newURI(escapeAddonURI(aAddon, aUpdate.updateInfoURL));
   }
   catch (e) {
     // If the releaseNotesURI cannot be parsed then just ignore it.
   }
   let install = new AddonInstall(aAddon._installLocation, url,
                                  aUpdate.updateHash, releaseNotesURI, aAddon);
   if (url instanceof Ci.nsIFileURL) {
     install.initLocalInstall(aCallback);
   }
   else {
     install.initAvailableDownload(aAddon.selectedLocale.name, aAddon.type,
                                   aAddon.icons, aUpdate.version, aCallback);
   }
 };
 /**
  * Creates a wrapper for an AddonInstall that only exposes the public API
  *
  * @param  install
  *         The AddonInstall to create a wrapper for
  */
 function AddonInstallWrapper(aInstall) {
 #ifdef MOZ_EM_DEBUG
   this.__defineGetter__("__AddonInstallInternal__", function AIW_debugGetter() {
     return aInstall;
   });
 #endif
   ["name", "type", "version", "icons", "releaseNotesURI", "file", "state", "error",
    "progress", "maxProgress", "certificate", "certName"].forEach(function(aProp) {
     this.__defineGetter__(aProp, function AIW_propertyGetter() aInstall[aProp]);
   }, this);
   this.__defineGetter__("iconURL", function AIW_iconURL() aInstall.icons[32]);
   this.__defineGetter__("existingAddon", function AIW_existingAddonGetter() {
     return createWrapper(aInstall.existingAddon);
   });
   this.__defineGetter__("addon", function AIW_addonGetter() createWrapper(aInstall.addon));
   this.__defineGetter__("sourceURI", function AIW_sourceURIGetter() aInstall.sourceURI);
   this.__defineGetter__("linkedInstalls", function AIW_linkedInstallsGetter() {
     if (!aInstall.linkedInstalls)
       return null;
     return [i.wrapper for each (i in aInstall.linkedInstalls)];
   });
   this.install = function AIW_install() {
     aInstall.install();
   }
   this.cancel = function AIW_cancel() {
     aInstall.cancel();
   }
   this.addListener = function AIW_addListener(listener) {
     aInstall.addListener(listener);
   }
   this.removeListener = function AIW_removeListener(listener) {
     aInstall.removeListener(listener);
   }
 }
 AddonInstallWrapper.prototype = {};
 /**
  * Creates a new update checker.
  *
  * @param  aAddon
  *         The add-on to check for updates
  * @param  aListener
  *         An UpdateListener to notify of updates
  * @param  aReason
  *         The reason for the update check
  * @param  aAppVersion
  *         An optional application version to check for updates for
  * @param  aPlatformVersion
  *         An optional platform version to check for updates for
  * @throws if the aListener or aReason arguments are not valid
  */
 function UpdateChecker(aAddon, aListener, aReason, aAppVersion, aPlatformVersion) {
   if (!aListener || !aReason)
     throw Cr.NS_ERROR_INVALID_ARG;
   Components.utils.import("resource://gre/modules/addons/AddonUpdateChecker.jsm");
   this.addon = aAddon;
   aAddon._updateCheck = this;
   XPIProvider.doing(this);
   this.listener = aListener;
   this.appVersion = aAppVersion;
   this.platformVersion = aPlatformVersion;
   this.syncCompatibility = (aReason == AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
   let updateURL = aAddon.updateURL;
   if (!updateURL) {
     if (aReason == AddonManager.UPDATE_WHEN_PERIODIC_UPDATE &&
         Services.prefs.getPrefType(PREF_EM_UPDATE_BACKGROUND_URL) == Services.prefs.PREF_STRING) {
       updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_BACKGROUND_URL);
     } else {
       updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_URL);
     }
   }
   const UPDATE_TYPE_COMPATIBILITY = 32;
   const UPDATE_TYPE_NEWVERSION = 64;
   aReason |= UPDATE_TYPE_COMPATIBILITY;
   if ("onUpdateAvailable" in this.listener)
     aReason |= UPDATE_TYPE_NEWVERSION;
   let url = escapeAddonURI(aAddon, updateURL, aReason, aAppVersion);
   this._parser = AddonUpdateChecker.checkForUpdates(aAddon.id, aAddon.updateKey,
                                                     url, this);
 }
 UpdateChecker.prototype = {
   addon: null,
   listener: null,
   appVersion: null,
   platformVersion: null,
   syncCompatibility: null,
   /**
    * Calls a method on the listener passing any number of arguments and
    * consuming any exceptions.
    *
    * @param  aMethod
    *         The method to call on the listener
    */
   callListener: function UC_callListener(aMethod, ...aArgs) {
     if (!(aMethod in this.listener))
       return;
     try {
       this.listener[aMethod].apply(this.listener, aArgs);
     }
     catch (e) {
       logger.warn("Exception calling UpdateListener method " + aMethod, e);
     }
   },
   /**
    * Called when AddonUpdateChecker completes the update check
    *
    * @param  updates
    *         The list of update details for the add-on
    */
   onUpdateCheckComplete: function UC_onUpdateCheckComplete(aUpdates) {
     XPIProvider.done(this.addon._updateCheck);
     this.addon._updateCheck = null;
     let AUC = AddonUpdateChecker;
     let ignoreMaxVersion = false;
     let ignoreStrictCompat = false;
     if (!AddonManager.checkCompatibility) {
       ignoreMaxVersion = true;
       ignoreStrictCompat = true;
     } else if (this.addon.type in COMPATIBLE_BY_DEFAULT_TYPES &&
                !AddonManager.strictCompatibility &&
                !this.addon.strictCompatibility &&
                !this.addon.hasBinaryComponents) {
       ignoreMaxVersion = true;
     }
     // Always apply any compatibility update for the current version
     let compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
                                                   this.syncCompatibility,
                                                   null, null,
                                                   ignoreMaxVersion,
                                                   ignoreStrictCompat);
     // Apply the compatibility update to the database
     if (compatUpdate)
       this.addon.applyCompatibilityUpdate(compatUpdate, this.syncCompatibility);
     // If the request is for an application or platform version that is
     // different to the current application or platform version then look for a
     // compatibility update for those versions.
     if ((this.appVersion &&
          Services.vc.compare(this.appVersion, Services.appinfo.version) != 0) ||
         (this.platformVersion &&
          Services.vc.compare(this.platformVersion, Services.appinfo.platformVersion) != 0)) {
       compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
                                                 false, this.appVersion,
                                                 this.platformVersion,
                                                 ignoreMaxVersion,
                                                 ignoreStrictCompat);
     }
     if (compatUpdate)
       this.callListener("onCompatibilityUpdateAvailable", createWrapper(this.addon));
     else
       this.callListener("onNoCompatibilityUpdateAvailable", createWrapper(this.addon));
     function sendUpdateAvailableMessages(aSelf, aInstall) {
       if (aInstall) {
         aSelf.callListener("onUpdateAvailable", createWrapper(aSelf.addon),
                            aInstall.wrapper);
       }
       else {
         aSelf.callListener("onNoUpdateAvailable", createWrapper(aSelf.addon));
       }
       aSelf.callListener("onUpdateFinished", createWrapper(aSelf.addon),
                          AddonManager.UPDATE_STATUS_NO_ERROR);
     }
     let compatOverrides = AddonManager.strictCompatibility ?
                             null :
                             this.addon.compatibilityOverrides;
     let update = AUC.getNewestCompatibleUpdate(aUpdates,
                                                this.appVersion,
                                                this.platformVersion,
                                                ignoreMaxVersion,
                                                ignoreStrictCompat,
                                                compatOverrides);
     if (update && Services.vc.compare(this.addon.version, update.version) < 0) {
       for (let currentInstall of XPIProvider.installs) {
         // Skip installs that don't match the available update
         if (currentInstall.existingAddon != this.addon ||
             currentInstall.version != update.version)
           continue;
         // If the existing install has not yet started downloading then send an
         // available update notification. If it is already downloading then
         // don't send any available update notification
         if (currentInstall.state == AddonManager.STATE_AVAILABLE) {
           logger.debug("Found an existing AddonInstall for " + this.addon.id);
           sendUpdateAvailableMessages(this, currentInstall);
         }
         else
           sendUpdateAvailableMessages(this, null);
         return;
       }
       let self = this;
       AddonInstall.createUpdate(function onUpdateCheckComplete_createUpdate(aInstall) {
         sendUpdateAvailableMessages(self, aInstall);
       }, this.addon, update);
     }
     else {
       sendUpdateAvailableMessages(this, null);
     }
   },
   /**
    * Called when AddonUpdateChecker fails the update check
    *
    * @param  aError
    *         An error status
    */
   onUpdateCheckError: function UC_onUpdateCheckError(aError) {
     XPIProvider.done(this.addon._updateCheck);
     this.addon._updateCheck = null;
     this.callListener("onNoCompatibilityUpdateAvailable", createWrapper(this.addon));
     this.callListener("onNoUpdateAvailable", createWrapper(this.addon));
     this.callListener("onUpdateFinished", createWrapper(this.addon), aError);
   },
   /**
    * Called to cancel an in-progress update check
    */
   cancel: function UC_cancel() {
     let parser = this._parser;
     if (parser) {
       this._parser = null;
       // This will call back to onUpdateCheckError with a CANCELLED error
       parser.cancel();
     }
   }
 };
 /**
  * The AddonInternal is an internal only representation of add-ons. It may
  * have come from the database (see DBAddonInternal in XPIProviderUtils.jsm)
  * or an install manifest.
  */
 function AddonInternal() {
 }
 AddonInternal.prototype = {
   _selectedLocale: null,
   active: false,
   visible: false,
   userDisabled: false,
   appDisabled: false,
   softDisabled: false,
   sourceURI: null,
   releaseNotesURI: null,
   foreignInstall: false,
   get selectedLocale() {
     if (this._selectedLocale)
       return this._selectedLocale;
     let locale = findClosestLocale(this.locales);
     this._selectedLocale = locale ? locale : this.defaultLocale;
     return this._selectedLocale;
   },
   get providesUpdatesSecurely() {
     return !!(this.updateKey || !this.updateURL ||
               this.updateURL.substring(0, 6) == "https:");
   },
   get isCompatible() {
     return this.isCompatibleWith();
   },
   get isPlatformCompatible() {
     if (this.targetPlatforms.length == 0)
       return true;
     let matchedOS = false;
     // If any targetPlatform matches the OS and contains an ABI then we will
     // only match a targetPlatform that contains both the current OS and ABI
     let needsABI = false;
     // Some platforms do not specify an ABI, test against null in that case.
     let abi = null;
     try {
       abi = Services.appinfo.XPCOMABI;
     }
     catch (e) { }
     for (let platform of this.targetPlatforms) {
       if (platform.os == Services.appinfo.OS) {
         if (platform.abi) {
           needsABI = true;
           if (platform.abi === abi)
             return true;
         }
         else {
           matchedOS = true;
         }
       }
     }
     return matchedOS && !needsABI;
   },
   isCompatibleWith: function AddonInternal_isCompatibleWith(aAppVersion, aPlatformVersion) {
     // Experiments are installed through an external mechanism that
     // limits target audience to compatible clients. We trust it knows what
     // it's doing and skip compatibility checks.
     //
     // This decision does forfeit defense in depth. If the experiments system
     // is ever wrong about targeting an add-on to a specific application
     // or platform, the client will likely see errors.
     if (this.type == "experiment") {
       return true;
     }
     let app = this.matchingTargetApplication;
     if (!app)
       return false;
     if (!aAppVersion)
       aAppVersion = Services.appinfo.version;
     if (!aPlatformVersion)
       aPlatformVersion = Services.appinfo.platformVersion;
     let version;
     if (app.id == Services.appinfo.ID)
       version = aAppVersion;
     else if (app.id == TOOLKIT_ID)
       version = aPlatformVersion
     // Only extensions and dictionaries can be compatible by default; themes
     // and language packs always use strict compatibility checking.
     if (this.type in COMPATIBLE_BY_DEFAULT_TYPES &&
         !AddonManager.strictCompatibility && !this.strictCompatibility &&
         !this.hasBinaryComponents) {
       // The repository can specify compatibility overrides.
       // Note: For now, only blacklisting is supported by overrides.
       if (this._repositoryAddon &&
           this._repositoryAddon.compatibilityOverrides) {
         let overrides = this._repositoryAddon.compatibilityOverrides;
         let override = AddonRepository.findMatchingCompatOverride(this.version,
                                                                   overrides);
         if (override && override.type == "incompatible")
           return false;
       }
       // Extremely old extensions should not be compatible by default.
       let minCompatVersion;
       if (app.id == Services.appinfo.ID)
         minCompatVersion = XPIProvider.minCompatibleAppVersion;
       else if (app.id == TOOLKIT_ID)
         minCompatVersion = XPIProvider.minCompatiblePlatformVersion;
       if (minCompatVersion &&
           Services.vc.compare(minCompatVersion, app.maxVersion) > 0)
         return false;
       return Services.vc.compare(version, app.minVersion) >= 0;
     }
     return (Services.vc.compare(version, app.minVersion) >= 0) &&
            (Services.vc.compare(version, app.maxVersion) <= 0)
   },
   get matchingTargetApplication() {
     let app = null;
     for (let targetApp of this.targetApplications) {
       if (targetApp.id == Services.appinfo.ID)
         return targetApp;
       if (targetApp.id == TOOLKIT_ID)
         app = targetApp;
     }
     return app;
   },
   get blocklistState() {
     let staticItem = findMatchingStaticBlocklistItem(this);
     if (staticItem)
       return staticItem.level;
     let bs = Cc["@mozilla.org/extensions/blocklist;1"].
              getService(Ci.nsIBlocklistService);
     return bs.getAddonBlocklistState(createWrapper(this));
   },
   get blocklistURL() {
     let staticItem = findMatchingStaticBlocklistItem(this);
     if (staticItem) {
       let url = Services.urlFormatter.formatURLPref("extensions.blocklist.itemURL");
       return url.replace(/%blockID%/g, staticItem.blockID);
     }
     let bs = Cc["@mozilla.org/extensions/blocklist;1"].
              getService(Ci.nsIBlocklistService);
     return bs.getAddonBlocklistURL(createWrapper(this));
   },
   applyCompatibilityUpdate: function AddonInternal_applyCompatibilityUpdate(aUpdate, aSyncCompatibility) {
     this.targetApplications.forEach(function(aTargetApp) {
       aUpdate.targetApplications.forEach(function(aUpdateTarget) {
         if (aTargetApp.id == aUpdateTarget.id && (aSyncCompatibility ||
             Services.vc.compare(aTargetApp.maxVersion, aUpdateTarget.maxVersion) < 0)) {
           aTargetApp.minVersion = aUpdateTarget.minVersion;
           aTargetApp.maxVersion = aUpdateTarget.maxVersion;
         }
       });
     });
     this.appDisabled = !isUsableAddon(this);
   },
   /**
    * toJSON is called by JSON.stringify in order to create a filtered version
    * of this object to be serialized to a JSON file. A new object is returned
    * with copies of all non-private properties. Functions, getters and setters
    * are not copied.
    *
    * @param  aKey
    *         The key that this object is being serialized as in the JSON.
    *         Unused here since this is always the main object serialized
    *
    * @return an object containing copies of the properties of this object
    *         ignoring private properties, functions, getters and setters
    */
   toJSON: function AddonInternal_toJSON(aKey) {
     let obj = {};
     for (let prop in this) {
       // Ignore private properties
       if (prop.substring(0, 1) == "_")
         continue;
       // Ignore getters
       if (this.__lookupGetter__(prop))
         continue;
       // Ignore setters
       if (this.__lookupSetter__(prop))
         continue;
       // Ignore functions
       if (typeof this[prop] == "function")
         continue;
       obj[prop] = this[prop];
     }
     return obj;
   },
   /**
    * When an add-on install is pending its metadata will be cached in a file.
    * This method reads particular properties of that metadata that may be newer
    * than that in the install manifest, like compatibility information.
    *
    * @param  aObj
    *         A JS object containing the cached metadata
    */
   importMetadata: function AddonInternal_importMetaData(aObj) {
     PENDING_INSTALL_METADATA.forEach(function(aProp) {
       if (!(aProp in aObj))
         return;
       this[aProp] = aObj[aProp];
     }, this);
     // Compatibility info may have changed so update appDisabled
     this.appDisabled = !isUsableAddon(this);
   }
 };
 /**
  * Creates an AddonWrapper for an AddonInternal.
  *
  * @param   addon
  *          The AddonInternal to wrap
  * @return  an AddonWrapper or null if addon was null
  */
 function createWrapper(aAddon) {
   if (!aAddon)
     return null;
   if (!aAddon._wrapper) {
     aAddon._hasResourceCache = new Map();
     aAddon._wrapper = new AddonWrapper(aAddon);
   }
   return aAddon._wrapper;
 }
 /**
  * The AddonWrapper wraps an Addon to provide the data visible to consumers of
  * the public API.
  */
 function AddonWrapper(aAddon) {
 #ifdef MOZ_EM_DEBUG
   this.__defineGetter__("__AddonInternal__", function AW_debugGetter() {
     return aAddon;
   });
 #endif
   function chooseValue(aObj, aProp) {
     let repositoryAddon = aAddon._repositoryAddon;
     let objValue = aObj[aProp];
     if (repositoryAddon && (aProp in repositoryAddon) &&
         (objValue === undefined || objValue === null)) {
       return [repositoryAddon[aProp], true];
     }
     return [objValue, false];
   }
   ["id", "syncGUID", "version", "type", "isCompatible", "isPlatformCompatible",
    "providesUpdatesSecurely", "blocklistState", "blocklistURL", "appDisabled",
    "softDisabled", "skinnable", "size", "foreignInstall", "hasBinaryComponents",
    "strictCompatibility", "compatibilityOverrides", "updateURL"].forEach(function(aProp) {
      this.__defineGetter__(aProp, function AddonWrapper_propertyGetter() aAddon[aProp]);
   }, this);
   ["fullDescription", "developerComments", "eula", "supportURL",
    "contributionURL", "contributionAmount", "averageRating", "reviewCount",
    "reviewURL", "totalDownloads", "weeklyDownloads", "dailyUsers",
    "repositoryStatus"].forEach(function(aProp) {
     this.__defineGetter__(aProp, function AddonWrapper_repoPropertyGetter() {
       if (aAddon._repositoryAddon)
         return aAddon._repositoryAddon[aProp];
       return null;
     });
   }, this);
   this.__defineGetter__("aboutURL", function AddonWrapper_aboutURLGetter() {
     return this.isActive ? aAddon["aboutURL"] : null;
   });
   ["installDate", "updateDate"].forEach(function(aProp) {
     this.__defineGetter__(aProp, function AddonWrapper_datePropertyGetter() new Date(aAddon[aProp]));
   }, this);
   ["sourceURI", "releaseNotesURI"].forEach(function(aProp) {
     this.__defineGetter__(aProp, function AddonWrapper_URIPropertyGetter() {
       let [target, fromRepo] = chooseValue(aAddon, aProp);
       if (!target)
         return null;
       if (fromRepo)
         return target;
       return NetUtil.newURI(target);
     });
   }, this);
   this.__defineGetter__("optionsURL", function AddonWrapper_optionsURLGetter() {
     if (this.isActive && aAddon.optionsURL)
       return aAddon.optionsURL;
     if (this.isActive && this.hasResource("options.xul"))
       return this.getResourceURI("options.xul").spec;
     return null;
   }, this);
   this.__defineGetter__("optionsType", function AddonWrapper_optionsTypeGetter() {
     if (!this.isActive)
       return null;
     let hasOptionsXUL = this.hasResource("options.xul");
     let hasOptionsURL = !!this.optionsURL;
     if (aAddon.optionsType) {
       switch (parseInt(aAddon.optionsType, 10)) {
       case AddonManager.OPTIONS_TYPE_DIALOG:
       case AddonManager.OPTIONS_TYPE_TAB:
         return hasOptionsURL ? aAddon.optionsType : null;
       case AddonManager.OPTIONS_TYPE_INLINE:
       case AddonManager.OPTIONS_TYPE_INLINE_INFO:
         return (hasOptionsXUL || hasOptionsURL) ? aAddon.optionsType : null;
       }
       return null;
     }
     if (hasOptionsXUL)
       return AddonManager.OPTIONS_TYPE_INLINE;
     if (hasOptionsURL)
       return AddonManager.OPTIONS_TYPE_DIALOG;
     return null;
   }, this);
   this.__defineGetter__("iconURL", function AddonWrapper_iconURLGetter() {
     return this.icons[32];
   }, this);
   this.__defineGetter__("icon64URL", function AddonWrapper_icon64URLGetter() {
     return this.icons[64];
   }, this);
   this.__defineGetter__("icons", function AddonWrapper_iconsGetter() {
     let icons = {};
     if (aAddon._repositoryAddon) {
       for (let size in aAddon._repositoryAddon.icons) {
         icons[size] = aAddon._repositoryAddon.icons[size];
       }
     }
     if (this.isActive && aAddon.iconURL) {
       icons[32] = aAddon.iconURL;
     } else if (this.hasResource("icon.png")) {
       icons[32] = this.getResourceURI("icon.png").spec;
     }
     if (this.isActive && aAddon.icon64URL) {
       icons[64] = aAddon.icon64URL;
     } else if (this.hasResource("icon64.png")) {
       icons[64] = this.getResourceURI("icon64.png").spec;
     }
     Object.freeze(icons);
     return icons;
   }, this);
   PROP_LOCALE_SINGLE.forEach(function(aProp) {
     this.__defineGetter__(aProp, function AddonWrapper_singleLocaleGetter() {
       // Override XPI creator if repository creator is defined
       if (aProp == "creator" &&
           aAddon._repositoryAddon && aAddon._repositoryAddon.creator) {
         return aAddon._repositoryAddon.creator;
       }
       let result = null;
       if (aAddon.active) {
         try {
           let pref = PREF_EM_EXTENSION_FORMAT + aAddon.id + "." + aProp;
           let value = Services.prefs.getComplexValue(pref,
                                                      Ci.nsIPrefLocalizedString);
           if (value.data)
             result = value.data;
         }
         catch (e) {
         }
       }
       if (result == null)
         [result, ] = chooseValue(aAddon.selectedLocale, aProp);
       if (aProp == "creator")
         return result ? new AddonManagerPrivate.AddonAuthor(result) : null;
       return result;
     });
   }, this);
   PROP_LOCALE_MULTI.forEach(function(aProp) {
     this.__defineGetter__(aProp, function AddonWrapper_multiLocaleGetter() {
       let results = null;
       let usedRepository = false;
       if (aAddon.active) {
         let pref = PREF_EM_EXTENSION_FORMAT + aAddon.id + "." +
                    aProp.substring(0, aProp.length - 1);
         let list = Services.prefs.getChildList(pref, {});
         if (list.length > 0) {
           list.sort();
           results = [];
           list.forEach(function(aPref) {
             let value = Services.prefs.getComplexValue(aPref,
                                                        Ci.nsIPrefLocalizedString);
             if (value.data)
               results.push(value.data);
           });
         }
       }
       if (results == null)
         [results, usedRepository] = chooseValue(aAddon.selectedLocale, aProp);
       if (results && !usedRepository) {
         results = results.map(function mapResult(aResult) {
           return new AddonManagerPrivate.AddonAuthor(aResult);
         });
       }
       return results;
     });
   }, this);
   this.__defineGetter__("screenshots", function AddonWrapper_screenshotsGetter() {
     let repositoryAddon = aAddon._repositoryAddon;
     if (repositoryAddon && ("screenshots" in repositoryAddon)) {
       let repositoryScreenshots = repositoryAddon.screenshots;
       if (repositoryScreenshots && repositoryScreenshots.length > 0)
         return repositoryScreenshots;
     }
     if (aAddon.type == "theme" && this.hasResource("preview.png")) {
       let url = this.getResourceURI("preview.png").spec;
       return [new AddonManagerPrivate.AddonScreenshot(url)];
     }
     return null;
   });
   this.__defineGetter__("applyBackgroundUpdates", function AddonWrapper_applyBackgroundUpdatesGetter() {
     return aAddon.applyBackgroundUpdates;
   });
   this.__defineSetter__("applyBackgroundUpdates", function AddonWrapper_applyBackgroundUpdatesSetter(val) {
     if (this.type == "experiment") {
       logger.warn("Setting applyBackgroundUpdates on an experiment is not supported.");
       return;
     }
     if (val != AddonManager.AUTOUPDATE_DEFAULT &&
         val != AddonManager.AUTOUPDATE_DISABLE &&
         val != AddonManager.AUTOUPDATE_ENABLE) {
       val = val ? AddonManager.AUTOUPDATE_DEFAULT :
                   AddonManager.AUTOUPDATE_DISABLE;
     }
     if (val == aAddon.applyBackgroundUpdates)
       return val;
     XPIDatabase.setAddonProperties(aAddon, {
       applyBackgroundUpdates: val
     });
     AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["applyBackgroundUpdates"]);
     return val;
   });
   this.__defineSetter__("syncGUID", function AddonWrapper_syncGUIDGetter(val) {
     if (aAddon.syncGUID == val)
       return val;
     if (aAddon.inDatabase)
       XPIDatabase.setAddonSyncGUID(aAddon, val);
     aAddon.syncGUID = val;
     return val;
   });
   this.__defineGetter__("install", function AddonWrapper_installGetter() {
     if (!("_install" in aAddon) || !aAddon._install)
       return null;
     return aAddon._install.wrapper;
   });
   this.__defineGetter__("pendingUpgrade", function AddonWrapper_pendingUpgradeGetter() {
     return createWrapper(aAddon.pendingUpgrade);
   });
   this.__defineGetter__("scope", function AddonWrapper_scopeGetter() {
     if (aAddon._installLocation)
       return aAddon._installLocation.scope;
     return AddonManager.SCOPE_PROFILE;
   });
   this.__defineGetter__("pendingOperations", function AddonWrapper_pendingOperationsGetter() {
     let pending = 0;
     if (!(aAddon.inDatabase)) {
       // Add-on is pending install if there is no associated install (shouldn't
       // happen here) or if the install is in the process of or has successfully
       // completed the install. If an add-on is pending install then we ignore
       // any other pending operations.
       if (!aAddon._install || aAddon._install.state == AddonManager.STATE_INSTALLING ||
           aAddon._install.state == AddonManager.STATE_INSTALLED)
         return AddonManager.PENDING_INSTALL;
     }
     else if (aAddon.pendingUninstall) {
       // If an add-on is pending uninstall then we ignore any other pending
       // operations
       return AddonManager.PENDING_UNINSTALL;
     }
     if (aAddon.active && isAddonDisabled(aAddon))
       pending |= AddonManager.PENDING_DISABLE;
     else if (!aAddon.active && !isAddonDisabled(aAddon))
       pending |= AddonManager.PENDING_ENABLE;
     if (aAddon.pendingUpgrade)
       pending |= AddonManager.PENDING_UPGRADE;
     return pending;
   });
   this.__defineGetter__("operationsRequiringRestart", function AddonWrapper_operationsRequiringRestartGetter() {
     let ops = 0;
     if (XPIProvider.installRequiresRestart(aAddon))
       ops |= AddonManager.OP_NEEDS_RESTART_INSTALL;
     if (XPIProvider.uninstallRequiresRestart(aAddon))
       ops |= AddonManager.OP_NEEDS_RESTART_UNINSTALL;
     if (XPIProvider.enableRequiresRestart(aAddon))
       ops |= AddonManager.OP_NEEDS_RESTART_ENABLE;
     if (XPIProvider.disableRequiresRestart(aAddon))
       ops |= AddonManager.OP_NEEDS_RESTART_DISABLE;
     return ops;
   });
   this.__defineGetter__("isDebuggable", function AddonWrapper_isDebuggable() {
     return this.isActive && aAddon.bootstrap;
   });
   this.__defineGetter__("permissions", function AddonWrapper_permisionsGetter() {
     let permissions = 0;
     // Add-ons that aren't installed cannot be modified in any way
     if (!(aAddon.inDatabase))
       return permissions;
     // Experiments can only be uninstalled. An uninstall reflects the user
     // intent of "disable this experiment." This is partially managed by the
     // experiments manager.
     if (aAddon.type == "experiment") {
       return AddonManager.PERM_CAN_UNINSTALL;
     }
     if (!aAddon.appDisabled) {
       if (this.userDisabled) {
         permissions |= AddonManager.PERM_CAN_ENABLE;
       }
       else if (aAddon.type != "theme") {
         permissions |= AddonManager.PERM_CAN_DISABLE;
       }
     }
     // Add-ons that are in locked install locations, or are pending uninstall
     // cannot be upgraded or uninstalled
     if (!aAddon._installLocation.locked && !aAddon.pendingUninstall) {
       // Add-ons that are installed by a file link cannot be upgraded
       if (!aAddon._installLocation.isLinkedAddon(aAddon.id)) {
         permissions |= AddonManager.PERM_CAN_UPGRADE;
       }
       permissions |= AddonManager.PERM_CAN_UNINSTALL;
     }
     return permissions;
   });
   this.__defineGetter__("isActive", function AddonWrapper_isActiveGetter() {
     if (Services.appinfo.inSafeMode)
       return false;
     return aAddon.active;
   });
   this.__defineGetter__("userDisabled", function AddonWrapper_userDisabledGetter() {
     if (XPIProvider._enabledExperiments.has(aAddon.id)) {
       return false;
     }
     return aAddon.softDisabled || aAddon.userDisabled;
   });
   this.__defineSetter__("userDisabled", function AddonWrapper_userDisabledSetter(val) {
     if (val == this.userDisabled) {
       return val;
     }
     if (aAddon.type == "experiment") {
       if (val) {
         XPIProvider._enabledExperiments.delete(aAddon.id);
       } else {
         XPIProvider._enabledExperiments.add(aAddon.id);
       }
     }
     if (aAddon.inDatabase) {
       if (aAddon.type == "theme" && val) {
         if (aAddon.internalName == XPIProvider.defaultSkin)
           throw new Error("Cannot disable the default theme");
         XPIProvider.enableDefaultTheme();
       }
       else {
         XPIProvider.updateAddonDisabledState(aAddon, val);
       }
     }
     else {
       aAddon.userDisabled = val;
       // When enabling remove the softDisabled flag
       if (!val)
         aAddon.softDisabled = false;
     }
     return val;
   });
   this.__defineSetter__("softDisabled", function AddonWrapper_softDisabledSetter(val) {
     if (val == aAddon.softDisabled)
       return val;
     if (aAddon.inDatabase) {
       // When softDisabling a theme just enable the active theme
       if (aAddon.type == "theme" && val && !aAddon.userDisabled) {
         if (aAddon.internalName == XPIProvider.defaultSkin)
           throw new Error("Cannot disable the default theme");
         XPIProvider.enableDefaultTheme();
       }
       else {
         XPIProvider.updateAddonDisabledState(aAddon, undefined, val);
       }
     }
     else {
       // Only set softDisabled if not already disabled
       if (!aAddon.userDisabled)
         aAddon.softDisabled = val;
     }
     return val;
   });
   this.isCompatibleWith = function AddonWrapper_isCompatiblewith(aAppVersion, aPlatformVersion) {
     return aAddon.isCompatibleWith(aAppVersion, aPlatformVersion);
   };
   this.uninstall = function AddonWrapper_uninstall() {
     if (!(aAddon.inDatabase))
       throw new Error("Cannot uninstall an add-on that isn't installed");
     if (aAddon.pendingUninstall)
       throw new Error("Add-on is already marked to be uninstalled");
     XPIProvider.uninstallAddon(aAddon);
   };
   this.cancelUninstall = function AddonWrapper_cancelUninstall() {
     if (!(aAddon.inDatabase))
       throw new Error("Cannot cancel uninstall for an add-on that isn't installed");
     if (!aAddon.pendingUninstall)
       throw new Error("Add-on is not marked to be uninstalled");
     XPIProvider.cancelUninstallAddon(aAddon);
   };
   this.findUpdates = function AddonWrapper_findUpdates(aListener, aReason, aAppVersion, aPlatformVersion) {
     // Short-circuit updates for experiments because updates are handled
     // through the Experiments Manager.
     if (this.type == "experiment") {
       AddonManagerPrivate.callNoUpdateListeners(this, aListener, aReason,
                                                 aAppVersion, aPlatformVersion);
       return;
     }
     new UpdateChecker(aAddon, aListener, aReason, aAppVersion, aPlatformVersion);
   };
   // Returns true if there was an update in progress, false if there was no update to cancel
   this.cancelUpdate = function AddonWrapper_cancelUpdate() {
     if (aAddon._updateCheck) {
       aAddon._updateCheck.cancel();
       return true;
     }
     return false;
   };
   this.hasResource = function AddonWrapper_hasResource(aPath) {
     if (aAddon._hasResourceCache.has(aPath))
       return aAddon._hasResourceCache.get(aPath);
     let bundle = aAddon._sourceBundle.clone();
     // Bundle may not exist any more if the addon has just been uninstalled,
     // but explicitly first checking .exists() results in unneeded file I/O.
     try {
       var isDir = bundle.isDirectory();
     } catch (e) {
       aAddon._hasResourceCache.set(aPath, false);
       return false;
     }
     if (isDir) {
       if (aPath) {
         aPath.split("/").forEach(function(aPart) {
           bundle.append(aPart);
         });
       }
       let result = bundle.exists();
       aAddon._hasResourceCache.set(aPath, result);
       return result;
     }
     let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
                     createInstance(Ci.nsIZipReader);
     try {
       zipReader.open(bundle);
       let result = zipReader.hasEntry(aPath);
       aAddon._hasResourceCache.set(aPath, result);
       return result;
     }
     catch (e) {
       aAddon._hasResourceCache.set(aPath, false);
       return false;
     }
     finally {
       zipReader.close();
     }
   },
   /**
    * Returns a URI to the selected resource or to the add-on bundle if aPath
    * is null. URIs to the bundle will always be file: URIs. URIs to resources
    * will be file: URIs if the add-on is unpacked or jar: URIs if the add-on is
    * still an XPI file.
    *
    * @param  aPath
    *         The path in the add-on to get the URI for or null to get a URI to
    *         the file or directory the add-on is installed as.
    * @return an nsIURI
    */
   this.getResourceURI = function AddonWrapper_getResourceURI(aPath) {
     if (!aPath)
       return NetUtil.newURI(aAddon._sourceBundle);
     return getURIForResourceInFile(aAddon._sourceBundle, aPath);
   }
 }
 /**
  * An object which identifies a directory install location for add-ons. The
  * location consists of a directory which contains the add-ons installed in the
  * location.
  *
  * Each add-on installed in the location is either a directory containing the
  * add-on's files or a text file containing an absolute path to the directory
  * containing the add-ons files. The directory or text file must have the same
  * name as the add-on's ID.
  *
  * There may also a special directory named "staged" which can contain
  * directories with the same name as an add-on ID. If the directory is empty
  * then it means the add-on will be uninstalled from this location during the
  * next startup. If the directory contains the add-on's files then they will be
  * installed during the next startup.
  *
  * @param  aName
  *         The string identifier for the install location
  * @param  aDirectory
  *         The nsIFile directory for the install location
  * @param  aScope
  *         The scope of add-ons installed in this location
  * @param  aLocked
  *         true if add-ons cannot be installed, uninstalled or upgraded in the
  *         install location
  */
 function DirectoryInstallLocation(aName, aDirectory, aScope, aLocked) {
   this._name = aName;
   this.locked = aLocked;
   this._directory = aDirectory;
   this._scope = aScope
   this._IDToFileMap = {};
   this._FileToIDMap = {};
   this._linkedAddons = [];
   this._stagingDirLock = 0;
   if (!aDirectory.exists())
     return;
   if (!aDirectory.isDirectory())
     throw new Error("Location must be a directory.");
   this._readAddons();
 }
 DirectoryInstallLocation.prototype = {
   _name       : "",
   _directory   : null,
   _IDToFileMap : null,  // mapping from add-on ID to nsIFile
   _FileToIDMap : null,  // mapping from add-on path to add-on ID
   /**
    * Reads a directory linked to in a file.
    *
    * @param   file
    *          The file containing the directory path
    * @return  An nsIFile object representing the linked directory.
    */
   _readDirectoryFromFile: function DirInstallLocation__readDirectoryFromFile(aFile) {
     let fis = Cc["@mozilla.org/network/file-input-stream;1"].
               createInstance(Ci.nsIFileInputStream);
     fis.init(aFile, -1, -1, false);
     let line = { value: "" };
     if (fis instanceof Ci.nsILineInputStream)
       fis.readLine(line);
     fis.close();
     if (line.value) {
       let linkedDirectory = Cc["@mozilla.org/file/local;1"].
                             createInstance(Ci.nsIFile);
       try {
         linkedDirectory.initWithPath(line.value);
       }
       catch (e) {
         linkedDirectory.setRelativeDescriptor(aFile.parent, line.value);
       }
       if (!linkedDirectory.exists()) {
         logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
              " which does not exist");
         return null;
       }
       if (!linkedDirectory.isDirectory()) {
         logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
              " which is not a directory");
         return null;
       }
       return linkedDirectory;
     }
     logger.warn("File pointer " + aFile.path + " does not contain a path");
     return null;
   },
   /**
    * Finds all the add-ons installed in this location.
    */
   _readAddons: function DirInstallLocation__readAddons() {
     // Use a snapshot of the directory contents to avoid possible issues with
     // iterating over a directory while removing files from it (the YAFFS2
     // embedded filesystem has this issue, see bug 772238).
     let entries = getDirectoryEntries(this._directory);
     for (let entry of entries) {
       let id = entry.leafName;
       if (id == DIR_STAGE || id == DIR_XPI_STAGE || id == DIR_TRASH)
         continue;
       let directLoad = false;
       if (entry.isFile() &&
           id.substring(id.length - 4).toLowerCase() == ".xpi") {
         directLoad = true;
         id = id.substring(0, id.length - 4);
       }
       if (!gIDTest.test(id)) {
         logger.debug("Ignoring file entry whose name is not a valid add-on ID: " +
              entry.path);
         continue;
       }
       if (entry.isFile() && !directLoad) {
         let newEntry = this._readDirectoryFromFile(entry);
         if (!newEntry) {
           logger.debug("Deleting stale pointer file " + entry.path);
           try {
             entry.remove(true);
           }
           catch (e) {
             logger.warn("Failed to remove stale pointer file " + entry.path, e);
             // Failing to remove the stale pointer file is ignorable
           }
           continue;
         }
         entry = newEntry;
         this._linkedAddons.push(id);
       }
       this._IDToFileMap[id] = entry;
       this._FileToIDMap[entry.path] = id;
     }
   },
   /**
    * Gets the name of this install location.
    */
   get name() {
     return this._name;
   },
   /**
    * Gets the scope of this install location.
    */
   get scope() {
     return this._scope;
   },
   /**
    * Gets an array of nsIFiles for add-ons installed in this location.
    */
   get addonLocations() {
     let locations = [];
     for (let id in this._IDToFileMap) {
       locations.push(this._IDToFileMap[id].clone());
     }
     return locations;
   },
   /**
    * Gets the staging directory to put add-ons that are pending install and
    * uninstall into.
    *
    * @return an nsIFile
    */
   getStagingDir: function DirInstallLocation_getStagingDir() {
     let dir = this._directory.clone();
     dir.append(DIR_STAGE);
     return dir;
   },
   requestStagingDir: function() {
     this._stagingDirLock++;
     if (this._stagingDirPromise)
       return this._stagingDirPromise;
     OS.File.makeDir(this._directory.path);
     let stagepath = OS.Path.join(this._directory.path, DIR_STAGE);
     return this._stagingDirPromise = OS.File.makeDir(stagepath).then(null, (e) => {
       if (e instanceof OS.File.Error && e.becauseExists)
         return;
       logger.error("Failed to create staging directory", e);
       throw e;
     });
   },
   releaseStagingDir: function() {
     this._stagingDirLock--;
     if (this._stagingDirLock == 0) {
       this._stagingDirPromise = null;
       this.cleanStagingDir();
     }
     return Promise.resolve();
   },
   /**
    * Removes the specified files or directories in the staging directory and
    * then if the staging directory is empty attempts to remove it.
    *
    * @param  aLeafNames
    *         An array of file or directory to remove from the directory, the
    *         array may be empty
    */
   cleanStagingDir: function(aLeafNames = []) {
     let dir = this.getStagingDir();
     for (let name of aLeafNames) {
       let file = dir.clone();
       file.append(name);
       recursiveRemove(file);
     }
     if (this._stagingDirLock > 0)
       return;
     let dirEntries = dir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
     try {
       if (dirEntries.nextFile)
         return;
     }
     finally {
       dirEntries.close();
     }
     try {
       setFilePermissions(dir, FileUtils.PERMS_DIRECTORY);
       dir.remove(false);
     }
     catch (e) {
       logger.warn("Failed to remove staging dir", e);
       // Failing to remove the staging directory is ignorable
     }
   },
   /**
    * Gets the directory used by old versions for staging XPI and JAR files ready
    * to be installed.
    *
    * @return an nsIFile
    */
   getXPIStagingDir: function DirInstallLocation_getXPIStagingDir() {
     let dir = this._directory.clone();
     dir.append(DIR_XPI_STAGE);
     return dir;
   },
   /**
    * Returns a directory that is normally on the same filesystem as the rest of
    * the install location and can be used for temporarily storing files during
    * safe move operations. Calling this method will delete the existing trash
    * directory and its contents.
    *
    * @return an nsIFile
    */
   getTrashDir: function DirInstallLocation_getTrashDir() {
     let trashDir = this._directory.clone();
     trashDir.append(DIR_TRASH);
     if (trashDir.exists())
       recursiveRemove(trashDir);
     trashDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
     return trashDir;
   },
   /**
    * Installs an add-on into the install location.
    *
    * @param  aId
    *         The ID of the add-on to install
    * @param  aSource
    *         The source nsIFile to install from
    * @param  aExistingAddonID
    *         The ID of an existing add-on to uninstall at the same time
    * @param  aCopy
    *         If false the source files will be moved to the new location,
    *         otherwise they will only be copied
    * @return an nsIFile indicating where the add-on was installed to
    */
   installAddon: function DirInstallLocation_installAddon(aId, aSource,
                                                          aExistingAddonID,
                                                          aCopy) {
     let trashDir = this.getTrashDir();
     let transaction = new SafeInstallOperation();
     let self = this;
     function moveOldAddon(aId) {
       let file = self._directory.clone();
       file.append(aId);
       if (file.exists())
         transaction.move(file, trashDir);
       file = self._directory.clone();
       file.append(aId + ".xpi");
       if (file.exists()) {
         flushJarCache(file);
         transaction.move(file, trashDir);
       }
     }
     // If any of these operations fails the finally block will clean up the
     // temporary directory
     try {
       moveOldAddon(aId);
       if (aExistingAddonID && aExistingAddonID != aId)
         moveOldAddon(aExistingAddonID);
       if (aCopy) {
         transaction.copy(aSource, this._directory);
       }
       else {
         if (aSource.isFile())
           flushJarCache(aSource);
         transaction.move(aSource, this._directory);
       }
     }
     finally {
       // It isn't ideal if this cleanup fails but it isn't worth rolling back
       // the install because of it.
       try {
         recursiveRemove(trashDir);
       }
       catch (e) {
         logger.warn("Failed to remove trash directory when installing " + aId, e);
       }
     }
     let newFile = this._directory.clone();
     newFile.append(aSource.leafName);
     try {
       newFile.lastModifiedTime = Date.now();
     } catch (e)  {
       logger.warn("failed to set lastModifiedTime on " + newFile.path, e);
     }
     this._FileToIDMap[newFile.path] = aId;
     this._IDToFileMap[aId] = newFile;
     if (aExistingAddonID && aExistingAddonID != aId &&
         aExistingAddonID in this._IDToFileMap) {
       delete this._FileToIDMap[this._IDToFileMap[aExistingAddonID]];
       delete this._IDToFileMap[aExistingAddonID];
     }
     return newFile;
   },
   /**
    * Uninstalls an add-on from this location.
    *
    * @param  aId
    *         The ID of the add-on to uninstall
    * @throws if the ID does not match any of the add-ons installed
    */
   uninstallAddon: function DirInstallLocation_uninstallAddon(aId) {
     let file = this._IDToFileMap[aId];
     if (!file) {
       logger.warn("Attempted to remove " + aId + " from " +
            this._name + " but it was already gone");
       return;
     }
     file = this._directory.clone();
     file.append(aId);
     if (!file.exists())
       file.leafName += ".xpi";
     if (!file.exists()) {
       logger.warn("Attempted to remove " + aId + " from " +
            this._name + " but it was already gone");
       delete this._FileToIDMap[file.path];
       delete this._IDToFileMap[aId];
       return;
     }
     let trashDir = this.getTrashDir();
     if (file.leafName != aId) {
       logger.debug("uninstallAddon: flushing jar cache " + file.path + " for addon " + aId);
       flushJarCache(file);
     }
     let transaction = new SafeInstallOperation();
     try {
       transaction.move(file, trashDir);
     }
     finally {
       // It isn't ideal if this cleanup fails, but it is probably better than
       // rolling back the uninstall at this point
       try {
         recursiveRemove(trashDir);
       }
       catch (e) {
         logger.warn("Failed to remove trash directory when uninstalling " + aId, e);
       }
     }
     delete this._FileToIDMap[file.path];
     delete this._IDToFileMap[aId];
   },
   /**
    * Gets the ID of the add-on installed in the given nsIFile.
    *
    * @param  aFile
    *         The nsIFile to look in
    * @return the ID
    * @throws if the file does not represent an installed add-on
    */
   getIDForLocation: function DirInstallLocation_getIDForLocation(aFile) {
     if (aFile.path in this._FileToIDMap)
       return this._FileToIDMap[aFile.path];
     throw new Error("Unknown add-on location " + aFile.path);
   },
   /**
    * Gets the directory that the add-on with the given ID is installed in.
    *
    * @param  aId
    *         The ID of the add-on
    * @return The nsIFile
    * @throws if the ID does not match any of the add-ons installed
    */
   getLocationForID: function DirInstallLocation_getLocationForID(aId) {
     if (aId in this._IDToFileMap)
       return this._IDToFileMap[aId].clone();
     throw new Error("Unknown add-on ID " + aId);
   },
   /**
    * Returns true if the given addon was installed in this location by a text
    * file pointing to its real path.
    *
    * @param aId
    *        The ID of the addon
    */
   isLinkedAddon: function DirInstallLocation__isLinkedAddon(aId) {
     return this._linkedAddons.indexOf(aId) != -1;
   }
 };
 #ifdef XP_WIN
 /**
  * An object that identifies a registry install location for add-ons. The location
  * consists of a registry key which contains string values mapping ID to the
  * path where an add-on is installed
  *
  * @param  aName
  *         The string identifier of this Install Location.
  * @param  aRootKey
  *         The root key (one of the ROOT_KEY_ values from nsIWindowsRegKey).
  * @param  scope
  *         The scope of add-ons installed in this location
  */
 function WinRegInstallLocation(aName, aRootKey, aScope) {
   this.locked = true;
   this._name = aName;
   this._rootKey = aRootKey;
   this._scope = aScope;
   this._IDToFileMap = {};
   this._FileToIDMap = {};
   let path = this._appKeyPath + "\\Extensions";
   let key = Cc["@mozilla.org/windows-registry-key;1"].
             createInstance(Ci.nsIWindowsRegKey);
   // Reading the registry may throw an exception, and that's ok.  In error
   // cases, we just leave ourselves in the empty state.
   try {
     key.open(this._rootKey, path, Ci.nsIWindowsRegKey.ACCESS_READ);
   }
   catch (e) {
     return;
   }
   this._readAddons(key);
   key.close();
 }
 WinRegInstallLocation.prototype = {
   _name       : "",
   _rootKey    : null,
   _scope      : null,
   _IDToFileMap : null,  // mapping from ID to nsIFile
   _FileToIDMap : null,  // mapping from path to ID
   /**
    * Retrieves the path of this Application's data key in the registry.
    */
   get _appKeyPath() {
     let appVendor = Services.appinfo.vendor;
     let appName = Services.appinfo.name;
 #ifdef MOZ_THUNDERBIRD
     // XXX Thunderbird doesn't specify a vendor string
     if (appVendor == "")
       appVendor = "Mozilla";
 #endif
     // XULRunner-based apps may intentionally not specify a vendor
     if (appVendor != "")
       appVendor += "\\";
     return "SOFTWARE\\" + appVendor + appName;
   },
   /**
    * Read the registry and build a mapping between ID and path for each
    * installed add-on.
    *
    * @param  key
    *         The key that contains the ID to path mapping
    */
   _readAddons: function RegInstallLocation__readAddons(aKey) {
     let count = aKey.valueCount;
     for (let i = 0; i < count; ++i) {
       let id = aKey.getValueName(i);
       let file = Cc["@mozilla.org/file/local;1"].
                 createInstance(Ci.nsIFile);
       file.initWithPath(aKey.readStringValue(id));
       if (!file.exists()) {
         logger.warn("Ignoring missing add-on in " + file.path);
         continue;
       }
       this._IDToFileMap[id] = file;
       this._FileToIDMap[file.path] = id;
     }
   },
   /**
    * Gets the name of this install location.
    */
   get name() {
     return this._name;
   },
   /**
    * Gets the scope of this install location.
    */
   get scope() {
     return this._scope;
   },
   /**
    * Gets an array of nsIFiles for add-ons installed in this location.
    */
   get addonLocations() {
     let locations = [];
     for (let id in this._IDToFileMap) {
       locations.push(this._IDToFileMap[id].clone());
     }
     return locations;
   },
   /**
    * Gets the ID of the add-on installed in the given nsIFile.
    *
    * @param  aFile
    *         The nsIFile to look in
    * @return the ID
    * @throws if the file does not represent an installed add-on
    */
   getIDForLocation: function RegInstallLocation_getIDForLocation(aFile) {
     if (aFile.path in this._FileToIDMap)
       return this._FileToIDMap[aFile.path];
     throw new Error("Unknown add-on location");
   },
   /**
    * Gets the nsIFile that the add-on with the given ID is installed in.
    *
    * @param  aId
    *         The ID of the add-on
    * @return the nsIFile
    */
   getLocationForID: function RegInstallLocation_getLocationForID(aId) {
     if (aId in this._IDToFileMap)
       return this._IDToFileMap[aId].clone();
     throw new Error("Unknown add-on ID");
   },
   /**
    * @see DirectoryInstallLocation
    */
   isLinkedAddon: function RegInstallLocation_isLinkedAddon(aId) {
     return true;
   }
 };
 #endif
 let addonTypes = [
   new AddonManagerPrivate.AddonType("extension", URI_EXTENSION_STRINGS,
                                     STRING_TYPE_NAME,
                                     AddonManager.VIEW_TYPE_LIST, 4000),
   new AddonManagerPrivate.AddonType("theme", URI_EXTENSION_STRINGS,
                                     STRING_TYPE_NAME,
                                     AddonManager.VIEW_TYPE_LIST, 5000),
   new AddonManagerPrivate.AddonType("dictionary", URI_EXTENSION_STRINGS,
                                     STRING_TYPE_NAME,
                                     AddonManager.VIEW_TYPE_LIST, 7000,
                                     AddonManager.TYPE_UI_HIDE_EMPTY),
   new AddonManagerPrivate.AddonType("locale", URI_EXTENSION_STRINGS,
                                     STRING_TYPE_NAME,
                                     AddonManager.VIEW_TYPE_LIST, 8000,
                                     AddonManager.TYPE_UI_HIDE_EMPTY),
 ];
 // We only register experiments support if the application supports them.
 // Ideally, we would install an observer to watch the pref. Installing
 // an observer for this pref is not necessary here and may be buggy with
 // regards to registering this XPIProvider twice.
 if (Prefs.getBoolPref("experiments.supported", false)) {
   addonTypes.push(
     new AddonManagerPrivate.AddonType("experiment",
                                       URI_EXTENSION_STRINGS,
                                       STRING_TYPE_NAME,
                                       AddonManager.VIEW_TYPE_LIST, 11000,
                                       AddonManager.TYPE_UI_HIDE_EMPTY));
 }
 AddonManagerPrivate.registerProvider(XPIProvider, addonTypes);

The Tor Browser / annotate

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

toolkit/mozapps/extensions/internal/XPIProvider.jsm