The Tor Browser / file revision

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 "use strict";

 const Cc = Components.classes;

 const Ci = Components.interfaces;

 const Cr = Components.results;

 const Cu = Components.utils;

 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