Move WebExtensions enabled Add-ons Manager

18 files changed, 19555 insertions, 0 deletions

diff --git a/toolkit/mozapps/webextensions/internal/APIExtensionBootstrap.js b/toolkit/mozapps/webextensions/internal/APIExtensionBootstrap.js
new file mode 100644
index 000000000..0eae2475c
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/APIExtensionBootstrap.js
@@ -0,0 +1,39 @@
+/* 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";
+
+Components.utils.import("resource://gre/modules/ExtensionManagement.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+var namespace;
+var resource;
+var resProto;
+
+function install(data, reason) {
+}
+
+function startup(data, reason) {
+  namespace = data.id.replace(/@.*/, "");
+  resource = `extension-${namespace}-api`;
+
+  resProto = Services.io.getProtocolHandler("resource")
+                     .QueryInterface(Components.interfaces.nsIResProtocolHandler);
+
+  resProto.setSubstitution(resource, data.resourceURI);
+
+  ExtensionManagement.registerAPI(
+    namespace,
+    `resource://${resource}/schema.json`,
+    `resource://${resource}/api.js`);
+}
+
+function shutdown(data, reason) {
+  resProto.setSubstitution(resource, null);
+
+  ExtensionManagement.unregisterAPI(namespace);
+}
+
+function uninstall(data, reason) {
+}
diff --git a/toolkit/mozapps/webextensions/internal/AddonConstants.jsm b/toolkit/mozapps/webextensions/internal/AddonConstants.jsm
new file mode 100644
index 000000000..22d91fdf5
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonConstants.jsm
@@ -0,0 +1,31 @@
+/* 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";
+
+this.EXPORTED_SYMBOLS = [ "ADDON_SIGNING", "REQUIRE_SIGNING" ];
+
+// Make these non-changable properties so they can't be manipulated from other
+// code in the app.
+Object.defineProperty(this, "ADDON_SIGNING", {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+#ifdef MOZ_ADDON_SIGNING
+  value: true,
+#else
+  value: false,
+#endif
+});
+
+Object.defineProperty(this, "REQUIRE_SIGNING", {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+#ifdef MOZ_REQUIRE_SIGNING
+  value: true,
+#else
+  value: false,
+#endif
+});
diff --git a/toolkit/mozapps/webextensions/internal/AddonLogging.jsm b/toolkit/mozapps/webextensions/internal/AddonLogging.jsm
new file mode 100644
index 000000000..f05a6fe6c
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonLogging.jsm
@@ -0,0 +1,192 @@
+/* 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 KEY_PROFILEDIR                  = "ProfD";
+const FILE_EXTENSIONS_LOG             = "extensions.log";
+const PREF_LOGGING_ENABLED            = "extensions.logging.enabled";
+
+const LOGGER_FILE_PERM                = parseInt("666", 8);
+
+const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed";
+
+Components.utils.import("resource://gre/modules/FileUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+this.EXPORTED_SYMBOLS = [ "LogManager" ];
+
+var gDebugLogEnabled = false;
+
+function formatLogMessage(aType, aName, aStr, aException) {
+  let message = aType.toUpperCase() + " " + aName + ": " + aStr;
+  if (aException) {
+    if (typeof aException == "number")
+      return message + ": " + Components.Exception("", aException).name;
+
+    message  = message + ": " + aException;
+    // instanceOf doesn't work here, let's duck type
+    if (aException.fileName)
+      message = message + " (" + aException.fileName + ":" + aException.lineNumber + ")";
+
+    if (aException.message == "too much recursion")
+      dump(message + "\n" + aException.stack + "\n");
+  }
+  return message;
+}
+
+function getStackDetails(aException) {
+  // Defensively wrap all this to ensure that failing to get the message source
+  // doesn't stop the message from being logged
+  try {
+    if (aException) {
+      if (aException instanceof Ci.nsIException) {
+        return {
+          sourceName: aException.filename,
+          lineNumber: aException.lineNumber
+        };
+      }
+
+      if (typeof aException == "object") {
+        return {
+          sourceName: aException.fileName,
+          lineNumber: aException.lineNumber
+        };
+      }
+    }
+
+    let stackFrame = Components.stack.caller.caller.caller;
+    return {
+      sourceName: stackFrame.filename,
+      lineNumber: stackFrame.lineNumber
+    };
+  }
+  catch (e) {
+    return {
+      sourceName: null,
+      lineNumber: 0
+    };
+  }
+}
+
+function AddonLogger(aName) {
+  this.name = aName;
+}
+
+AddonLogger.prototype = {
+  name: null,
+
+  error: function(aStr, aException) {
+    let message = formatLogMessage("error", this.name, aStr, aException);
+
+    let stack = getStackDetails(aException);
+
+    let consoleMessage = Cc["@mozilla.org/scripterror;1"].
+                         createInstance(Ci.nsIScriptError);
+    consoleMessage.init(message, stack.sourceName, null, stack.lineNumber, 0,
+                        Ci.nsIScriptError.errorFlag, "component javascript");
+    Services.console.logMessage(consoleMessage);
+
+    // Always dump errors, in case the Console Service isn't listening yet
+    dump("*** " + message + "\n");
+
+    function formatTimestamp(date) {
+      // Format timestamp as: "%Y-%m-%d %H:%M:%S"
+      let year = String(date.getFullYear());
+      let month = String(date.getMonth() + 1).padStart(2, "0");
+      let day = String(date.getDate()).padStart(2, "0");
+      let hours = String(date.getHours()).padStart(2, "0");
+      let minutes = String(date.getMinutes()).padStart(2, "0");
+      let seconds = String(date.getSeconds()).padStart(2, "0");
+
+      return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+    }
+
+    try {
+      var tstamp = new Date();
+      var logfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_EXTENSIONS_LOG]);
+      var stream = Cc["@mozilla.org/network/file-output-stream;1"].
+                   createInstance(Ci.nsIFileOutputStream);
+      stream.init(logfile, 0x02 | 0x08 | 0x10, LOGGER_FILE_PERM, 0); // write, create, append
+      var writer = Cc["@mozilla.org/intl/converter-output-stream;1"].
+                   createInstance(Ci.nsIConverterOutputStream);
+      writer.init(stream, "UTF-8", 0, 0x0000);
+      writer.writeString(formatTimestamp(tstamp) + " " +
+                         message + " at " + stack.sourceName + ":" +
+                         stack.lineNumber + "\n");
+      writer.close();
+    }
+    catch (e) { }
+  },
+
+  warn: function(aStr, aException) {
+    let message = formatLogMessage("warn", this.name, aStr, aException);
+
+    let stack = getStackDetails(aException);
+
+    let consoleMessage = Cc["@mozilla.org/scripterror;1"].
+                         createInstance(Ci.nsIScriptError);
+    consoleMessage.init(message, stack.sourceName, null, stack.lineNumber, 0,
+                        Ci.nsIScriptError.warningFlag, "component javascript");
+    Services.console.logMessage(consoleMessage);
+
+    if (gDebugLogEnabled)
+      dump("*** " + message + "\n");
+  },
+
+  log: function(aStr, aException) {
+    if (gDebugLogEnabled) {
+      let message = formatLogMessage("log", this.name, aStr, aException);
+      dump("*** " + message + "\n");
+      Services.console.logStringMessage(message);
+    }
+  }
+};
+
+this.LogManager = {
+  getLogger: function(aName, aTarget) {
+    let logger = new AddonLogger(aName);
+
+    if (aTarget) {
+      ["error", "warn", "log"].forEach(function(name) {
+        let fname = name.toUpperCase();
+        delete aTarget[fname];
+        aTarget[fname] = function(aStr, aException) {
+          logger[name](aStr, aException);
+        };
+      });
+    }
+
+    return logger;
+  }
+};
+
+var PrefObserver = {
+  init: function() {
+    Services.prefs.addObserver(PREF_LOGGING_ENABLED, this, false);
+    Services.obs.addObserver(this, "xpcom-shutdown", false);
+    this.observe(null, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, PREF_LOGGING_ENABLED);
+  },
+
+  observe: function(aSubject, aTopic, aData) {
+    if (aTopic == "xpcom-shutdown") {
+      Services.prefs.removeObserver(PREF_LOGGING_ENABLED, this);
+      Services.obs.removeObserver(this, "xpcom-shutdown");
+    }
+    else if (aTopic == NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) {
+      try {
+        gDebugLogEnabled = Services.prefs.getBoolPref(PREF_LOGGING_ENABLED);
+      }
+      catch (e) {
+        gDebugLogEnabled = false;
+      }
+    }
+  }
+};
+
+PrefObserver.init();
diff --git a/toolkit/mozapps/webextensions/internal/AddonRepository.jsm b/toolkit/mozapps/webextensions/internal/AddonRepository.jsm
new file mode 100644
index 000000000..7f88d44ad
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonRepository.jsm
@@ -0,0 +1,1988 @@
+/* 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 Cu = Components.utils;
+const Cr = Components.results;
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/AddonManager.jsm");
+/* globals AddonManagerPrivate*/
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+                                  "resource://gre/modules/NetUtil.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredSave",
+                                  "resource://gre/modules/DeferredSave.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository_SQLiteMigrator",
+                                  "resource://gre/modules/addons/AddonRepository_SQLiteMigrator.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest",
+                                  "resource://gre/modules/ServiceRequest.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+                                  "resource://gre/modules/Task.jsm");
+
+
+this.EXPORTED_SYMBOLS = [ "AddonRepository" ];
+
+const PREF_GETADDONS_CACHE_ENABLED       = "extensions.getAddons.cache.enabled";
+const PREF_GETADDONS_CACHE_TYPES         = "extensions.getAddons.cache.types";
+const PREF_GETADDONS_CACHE_ID_ENABLED    = "extensions.%ID%.getAddons.cache.enabled"
+const PREF_GETADDONS_BROWSEADDONS        = "extensions.getAddons.browseAddons";
+const PREF_GETADDONS_BYIDS               = "extensions.getAddons.get.url";
+const PREF_GETADDONS_BYIDS_PERFORMANCE   = "extensions.getAddons.getWithPerformance.url";
+const PREF_GETADDONS_BROWSERECOMMENDED   = "extensions.getAddons.recommended.browseURL";
+const PREF_GETADDONS_GETRECOMMENDED      = "extensions.getAddons.recommended.url";
+const PREF_GETADDONS_BROWSESEARCHRESULTS = "extensions.getAddons.search.browseURL";
+const PREF_GETADDONS_GETSEARCHRESULTS    = "extensions.getAddons.search.url";
+const PREF_GETADDONS_DB_SCHEMA           = "extensions.getAddons.databaseSchema"
+
+const PREF_METADATA_LASTUPDATE           = "extensions.getAddons.cache.lastUpdate";
+const PREF_METADATA_UPDATETHRESHOLD_SEC  = "extensions.getAddons.cache.updateThreshold";
+const DEFAULT_METADATA_UPDATETHRESHOLD_SEC = 172800;  // two days
+
+const XMLURI_PARSE_ERROR  = "http://www.mozilla.org/newlayout/xml/parsererror.xml";
+
+const API_VERSION = "1.5";
+const DEFAULT_CACHE_TYPES = "extension,theme,locale,dictionary";
+
+const KEY_PROFILEDIR        = "ProfD";
+const FILE_DATABASE         = "addons.json";
+const DB_SCHEMA             = 5;
+const DB_MIN_JSON_SCHEMA    = 5;
+const DB_BATCH_TIMEOUT_MS   = 50;
+
+const BLANK_DB = function() {
+  return {
+    addons: new Map(),
+    schema: DB_SCHEMA
+  };
+}
+
+const TOOLKIT_ID     = "toolkit@mozilla.org";
+
+Cu.import("resource://gre/modules/Log.jsm");
+const LOGGER_ID = "addons.repository";
+
+// Create a new logger for use by the Addons Repository
+// (Requires AddonManager.jsm)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+// A map between XML keys to AddonSearchResult keys for string values
+// that require no extra parsing from XML
+const STRING_KEY_MAP = {
+  name:               "name",
+  version:            "version",
+  homepage:           "homepageURL",
+  support:            "supportURL"
+};
+
+// A map between XML keys to AddonSearchResult keys for string values
+// that require parsing from HTML
+const HTML_KEY_MAP = {
+  summary:            "description",
+  description:        "fullDescription",
+  developer_comments: "developerComments",
+  eula:               "eula"
+};
+
+// A map between XML keys to AddonSearchResult keys for integer values
+// that require no extra parsing from XML
+const INTEGER_KEY_MAP = {
+  total_downloads:  "totalDownloads",
+  weekly_downloads: "weeklyDownloads",
+  daily_users:      "dailyUsers"
+};
+
+function convertHTMLToPlainText(html) {
+  if (!html)
+    return html;
+  var converter = Cc["@mozilla.org/widget/htmlformatconverter;1"].
+                  createInstance(Ci.nsIFormatConverter);
+
+  var input = Cc["@mozilla.org/supports-string;1"].
+              createInstance(Ci.nsISupportsString);
+  input.data = html.replace(/\n/g, "<br>");
+
+  var output = {};
+  converter.convert("text/html", input, input.data.length, "text/unicode",
+                    output, {});
+
+  if (output.value instanceof Ci.nsISupportsString)
+    return output.value.data.replace(/\r\n/g, "\n");
+  return html;
+}
+
+function getAddonsToCache(aIds, aCallback) {
+  try {
+    var types = Services.prefs.getCharPref(PREF_GETADDONS_CACHE_TYPES);
+  }
+  catch (e) { }
+  if (!types)
+    types = DEFAULT_CACHE_TYPES;
+
+  types = types.split(",");
+
+  AddonManager.getAddonsByIDs(aIds, function(aAddons) {
+    let enabledIds = [];
+    for (var i = 0; i < aIds.length; i++) {
+      var preference = PREF_GETADDONS_CACHE_ID_ENABLED.replace("%ID%", aIds[i]);
+      try {
+        if (!Services.prefs.getBoolPref(preference))
+          continue;
+      } catch (e) {
+        // If the preference doesn't exist caching is enabled by default
+      }
+
+      // The add-ons manager may not know about this ID yet if it is a pending
+      // install. In that case we'll just cache it regardless
+      if (aAddons[i] && (types.indexOf(aAddons[i].type) == -1))
+        continue;
+
+      enabledIds.push(aIds[i]);
+    }
+
+    aCallback(enabledIds);
+  });
+}
+
+function AddonSearchResult(aId) {
+  this.id = aId;
+  this.icons = {};
+  this._unsupportedProperties = {};
+}
+
+AddonSearchResult.prototype = {
+  /**
+   * The ID of the add-on
+   */
+  id: null,
+
+  /**
+   * The add-on type (e.g. "extension" or "theme")
+   */
+  type: null,
+
+  /**
+   * The name of the add-on
+   */
+  name: null,
+
+  /**
+   * The version of the add-on
+   */
+  version: null,
+
+  /**
+   * The creator of the add-on
+   */
+  creator: null,
+
+  /**
+   * The developers of the add-on
+   */
+  developers: null,
+
+  /**
+   * A short description of the add-on
+   */
+  description: null,
+
+  /**
+   * The full description of the add-on
+   */
+  fullDescription: null,
+
+  /**
+   * The developer comments for the add-on. This includes any information
+   * that may be helpful to end users that isn't necessarily applicable to
+   * the add-on description (e.g. known major bugs)
+   */
+  developerComments: null,
+
+  /**
+   * The end-user licensing agreement (EULA) of the add-on
+   */
+  eula: null,
+
+  /**
+   * The url of the add-on's icon
+   */
+  get iconURL() {
+    return this.icons && this.icons[32];
+  },
+
+   /**
+   * The URLs of the add-on's icons, as an object with icon size as key
+   */
+  icons: null,
+
+  /**
+   * An array of screenshot urls for the add-on
+   */
+  screenshots: null,
+
+  /**
+   * The homepage for the add-on
+   */
+  homepageURL: null,
+
+  /**
+   * The homepage for the add-on
+   */
+  learnmoreURL: null,
+
+  /**
+   * The support URL for the add-on
+   */
+  supportURL: null,
+
+  /**
+   * The contribution url of the add-on
+   */
+  contributionURL: null,
+
+  /**
+   * The suggested contribution amount
+   */
+  contributionAmount: null,
+
+  /**
+   * The URL to visit in order to purchase the add-on
+   */
+  purchaseURL: null,
+
+  /**
+   * The numerical cost of the add-on in some currency, for sorting purposes
+   * only
+   */
+  purchaseAmount: null,
+
+  /**
+   * The display cost of the add-on, for display purposes only
+   */
+  purchaseDisplayAmount: null,
+
+  /**
+   * The rating of the add-on, 0-5
+   */
+  averageRating: null,
+
+  /**
+   * The number of reviews for this add-on
+   */
+  reviewCount: null,
+
+  /**
+   * The URL to the list of reviews for this add-on
+   */
+  reviewURL: null,
+
+  /**
+   * The total number of times the add-on was downloaded
+   */
+  totalDownloads: null,
+
+  /**
+   * The number of times the add-on was downloaded the current week
+   */
+  weeklyDownloads: null,
+
+  /**
+   * The number of daily users for the add-on
+   */
+  dailyUsers: null,
+
+  /**
+   * AddonInstall object generated from the add-on XPI url
+   */
+  install: null,
+
+  /**
+   * nsIURI storing where this add-on was installed from
+   */
+  sourceURI: null,
+
+  /**
+   * The status of the add-on in the repository (e.g. 4 = "Public")
+   */
+  repositoryStatus: null,
+
+  /**
+   * The size of the add-on's files in bytes. For an add-on that have not yet
+   * been downloaded this may be an estimated value.
+   */
+  size: null,
+
+  /**
+   * The Date that the add-on was most recently updated
+   */
+  updateDate: null,
+
+  /**
+   * True or false depending on whether the add-on is compatible with the
+   * current version of the application
+   */
+  isCompatible: true,
+
+  /**
+   * True or false depending on whether the add-on is compatible with the
+   * current platform
+   */
+  isPlatformCompatible: true,
+
+  /**
+   * Array of AddonCompatibilityOverride objects, that describe overrides for
+   * compatibility with an application versions.
+   **/
+  compatibilityOverrides: null,
+
+  /**
+   * True if the add-on has a secure means of updating
+   */
+  providesUpdatesSecurely: true,
+
+  /**
+   * The current blocklist state of the add-on
+   */
+  blocklistState: Ci.nsIBlocklistService.STATE_NOT_BLOCKED,
+
+  /**
+   * True if this add-on cannot be used in the application based on version
+   * compatibility, dependencies and blocklisting
+   */
+  appDisabled: false,
+
+  /**
+   * True if the user wants this add-on to be disabled
+   */
+  userDisabled: false,
+
+  /**
+   * Indicates what scope the add-on is installed in, per profile, user,
+   * system or application
+   */
+  scope: AddonManager.SCOPE_PROFILE,
+
+  /**
+   * True if the add-on is currently functional
+   */
+  isActive: true,
+
+  /**
+   * A bitfield holding all of the current operations that are waiting to be
+   * performed for this add-on
+   */
+  pendingOperations: AddonManager.PENDING_NONE,
+
+  /**
+   * A bitfield holding all the the operations that can be performed on
+   * this add-on
+   */
+  permissions: 0,
+
+  /**
+   * Tests whether this add-on is known to be compatible with a
+   * particular application and platform version.
+   *
+   * @param  appVersion
+   *         An application version to test against
+   * @param  platformVersion
+   *         A platform version to test against
+   * @return Boolean representing if the add-on is compatible
+   */
+  isCompatibleWith: function(aAppVersion, aPlatformVersion) {
+    return true;
+  },
+
+  /**
+   * Starts an update check for this add-on. This will perform
+   * asynchronously and deliver results to the given listener.
+   *
+   * @param  aListener
+   *         An UpdateListener for the update process
+   * @param  aReason
+   *         A reason code for performing the update
+   * @param  aAppVersion
+   *         An application version to check for updates for
+   * @param  aPlatformVersion
+   *         A platform version to check for updates for
+   */
+  findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) {
+    if ("onNoCompatibilityUpdateAvailable" in aListener)
+      aListener.onNoCompatibilityUpdateAvailable(this);
+    if ("onNoUpdateAvailable" in aListener)
+      aListener.onNoUpdateAvailable(this);
+    if ("onUpdateFinished" in aListener)
+      aListener.onUpdateFinished(this);
+  },
+
+  toJSON: function() {
+    let json = {};
+
+    for (let property of Object.keys(this)) {
+      let value = this[property];
+      if (property.startsWith("_") ||
+          typeof(value) === "function")
+        continue;
+
+      try {
+        switch (property) {
+          case "sourceURI":
+            json.sourceURI = value ? value.spec : "";
+            break;
+
+          case "updateDate":
+            json.updateDate = value ? value.getTime() : "";
+            break;
+
+          default:
+            json[property] = value;
+        }
+      } catch (ex) {
+        logger.warn("Error writing property value for " + property);
+      }
+    }
+
+    for (let property of Object.keys(this._unsupportedProperties)) {
+      let value = this._unsupportedProperties[property];
+      if (!property.startsWith("_"))
+        json[property] = value;
+    }
+
+    return json;
+  }
+}
+
+/**
+ * The add-on repository is a source of add-ons that can be installed. It can
+ * be searched in three ways. The first takes a list of IDs and returns a
+ * list of the corresponding add-ons. The second returns a list of add-ons that
+ * come highly recommended. This list should change frequently. The third is to
+ * search for specific search terms entered by the user. Searches are
+ * asynchronous and results should be passed to the provided callback object
+ * when complete. The results passed to the callback should only include add-ons
+ * that are compatible with the current application and are not already
+ * installed.
+ */
+this.AddonRepository = {
+  /**
+   * Whether caching is currently enabled
+   */
+  get cacheEnabled() {
+    let preference = PREF_GETADDONS_CACHE_ENABLED;
+    let enabled = false;
+    try {
+      enabled = Services.prefs.getBoolPref(preference);
+    } catch (e) {
+      logger.warn("cacheEnabled: Couldn't get pref: " + preference);
+    }
+
+    return enabled;
+  },
+
+  // A cache of the add-ons stored in the database
+  _addons: null,
+
+  // Whether a search is currently in progress
+  _searching: false,
+
+  // XHR associated with the current request
+  _request: null,
+
+  /*
+   * Addon search results callback object that contains two functions
+   *
+   * searchSucceeded - Called when a search has suceeded.
+   *
+   * @param  aAddons
+   *         An array of the add-on results. In the case of searching for
+   *         specific terms the ordering of results may be determined by
+   *         the search provider.
+   * @param  aAddonCount
+   *         The length of aAddons
+   * @param  aTotalResults
+   *         The total results actually available in the repository
+   *
+   *
+   * searchFailed - Called when an error occurred when performing a search.
+   */
+  _callback: null,
+
+  // Maximum number of results to return
+  _maxResults: null,
+
+  /**
+   * Shut down AddonRepository
+   * return: promise{integer} resolves with the result of flushing
+   *         the AddonRepository database
+   */
+  shutdown: function() {
+    this.cancelSearch();
+
+    this._addons = null;
+    return AddonDatabase.shutdown(false);
+  },
+
+  metadataAge: function() {
+    let now = Math.round(Date.now() / 1000);
+
+    let lastUpdate = 0;
+    try {
+      lastUpdate = Services.prefs.getIntPref(PREF_METADATA_LASTUPDATE);
+    } catch (e) {}
+
+    // Handle clock jumps
+    if (now < lastUpdate) {
+      return now;
+    }
+    return now - lastUpdate;
+  },
+
+  isMetadataStale: function() {
+    let threshold = DEFAULT_METADATA_UPDATETHRESHOLD_SEC;
+    try {
+      threshold = Services.prefs.getIntPref(PREF_METADATA_UPDATETHRESHOLD_SEC);
+    } catch (e) {}
+    return (this.metadataAge() > threshold);
+  },
+
+  /**
+   * Asynchronously get a cached add-on by id. The add-on (or null if the
+   * add-on is not found) is passed to the specified callback. If caching is
+   * disabled, null is passed to the specified callback.
+   *
+   * @param  aId
+   *         The id of the add-on to get
+   * @param  aCallback
+   *         The callback to pass the result back to
+   */
+  getCachedAddonByID: Task.async(function*(aId, aCallback) {
+    if (!aId || !this.cacheEnabled) {
+      aCallback(null);
+      return;
+    }
+
+    function getAddon(aAddons) {
+      aCallback(aAddons.get(aId) || null);
+    }
+
+    if (this._addons == null) {
+      AddonDatabase.retrieveStoredData().then(aAddons => {
+        this._addons = aAddons;
+        getAddon(aAddons);
+      });
+
+      return;
+    }
+
+    getAddon(this._addons);
+  }),
+
+  /**
+   * Asynchronously repopulate cache so it only contains the add-ons
+   * corresponding to the specified ids. If caching is disabled,
+   * the cache is completely removed.
+   *
+   * @param  aTimeout
+   *         (Optional) timeout in milliseconds to abandon the XHR request
+   *         if we have not received a response from the server.
+   * @return Promise{null}
+   *         Resolves when the metadata ping is complete
+   */
+  repopulateCache: function(aTimeout) {
+    return this._repopulateCacheInternal(false, aTimeout);
+  },
+
+  /*
+   * Clear and delete the AddonRepository database
+   * @return Promise{null} resolves when the database is deleted
+   */
+  _clearCache: function() {
+    this._addons = null;
+    return AddonDatabase.delete().then(() =>
+      new Promise((resolve, reject) =>
+        AddonManagerPrivate.updateAddonRepositoryData(resolve))
+    );
+  },
+
+  _repopulateCacheInternal: Task.async(function*(aSendPerformance, aTimeout) {
+    let allAddons = yield new Promise((resolve, reject) =>
+      AddonManager.getAllAddons(resolve));
+
+    // Filter the hotfix out of our list of add-ons
+    allAddons = allAddons.filter(a => a.id != AddonManager.hotfixID);
+
+    // Completely remove cache if caching is not enabled
+    if (!this.cacheEnabled) {
+      logger.debug("Clearing cache because it is disabled");
+      yield this._clearCache();
+      return;
+    }
+
+    let ids = allAddons.map(a => a.id);
+    logger.debug("Repopulate add-on cache with " + ids.toSource());
+
+    let addonsToCache = yield new Promise((resolve, reject) =>
+      getAddonsToCache(ids, resolve));
+
+    // Completely remove cache if there are no add-ons to cache
+    if (addonsToCache.length == 0) {
+      logger.debug("Clearing cache because 0 add-ons were requested");
+      yield this._clearCache();
+      return;
+    }
+
+    yield new Promise((resolve, reject) =>
+      this._beginGetAddons(addonsToCache, {
+        searchSucceeded: aAddons => {
+          this._addons = new Map();
+          for (let addon of aAddons) {
+            this._addons.set(addon.id, addon);
+          }
+          AddonDatabase.repopulate(aAddons, resolve);
+        },
+        searchFailed: () => {
+          logger.warn("Search failed when repopulating cache");
+          resolve();
+        }
+      }, aSendPerformance, aTimeout));
+
+    // Always call AddonManager updateAddonRepositoryData after we refill the cache
+    yield new Promise((resolve, reject) =>
+      AddonManagerPrivate.updateAddonRepositoryData(resolve));
+  }),
+
+  /**
+   * Asynchronously add add-ons to the cache corresponding to the specified
+   * ids. If caching is disabled, the cache is unchanged and the callback is
+   * immediately called if it is defined.
+   *
+   * @param  aIds
+   *         The array of add-on ids to add to the cache
+   * @param  aCallback
+   *         The optional callback to call once complete
+   */
+  cacheAddons: function(aIds, aCallback) {
+    logger.debug("cacheAddons: enabled " + this.cacheEnabled + " IDs " + aIds.toSource());
+    if (!this.cacheEnabled) {
+      if (aCallback)
+        aCallback();
+      return;
+    }
+
+    getAddonsToCache(aIds, aAddons => {
+      // If there are no add-ons to cache, act as if caching is disabled
+      if (aAddons.length == 0) {
+        if (aCallback)
+          aCallback();
+        return;
+      }
+
+      this.getAddonsByIDs(aAddons, {
+        searchSucceeded: aAddons => {
+          for (let addon of aAddons) {
+            this._addons.set(addon.id, addon);
+          }
+          AddonDatabase.insertAddons(aAddons, aCallback);
+        },
+        searchFailed: () => {
+          logger.warn("Search failed when adding add-ons to cache");
+          if (aCallback)
+            aCallback();
+        }
+      });
+    });
+  },
+
+  /**
+   * The homepage for visiting this repository. If the corresponding preference
+   * is not defined, defaults to about:blank.
+   */
+  get homepageURL() {
+    let url = this._formatURLPref(PREF_GETADDONS_BROWSEADDONS, {});
+    return (url != null) ? url : "about:blank";
+  },
+
+  /**
+   * Returns whether this instance is currently performing a search. New
+   * searches will not be performed while this is the case.
+   */
+  get isSearching() {
+    return this._searching;
+  },
+
+  /**
+   * The url that can be visited to see recommended add-ons in this repository.
+   * If the corresponding preference is not defined, defaults to about:blank.
+   */
+  getRecommendedURL: function() {
+    let url = this._formatURLPref(PREF_GETADDONS_BROWSERECOMMENDED, {});
+    return (url != null) ? url : "about:blank";
+  },
+
+  /**
+   * Retrieves the url that can be visited to see search results for the given
+   * terms. If the corresponding preference is not defined, defaults to
+   * about:blank.
+   *
+   * @param  aSearchTerms
+   *         Search terms used to search the repository
+   */
+  getSearchURL: function(aSearchTerms) {
+    let url = this._formatURLPref(PREF_GETADDONS_BROWSESEARCHRESULTS, {
+      TERMS : encodeURIComponent(aSearchTerms)
+    });
+    return (url != null) ? url : "about:blank";
+  },
+
+  /**
+   * Cancels the search in progress. If there is no search in progress this
+   * does nothing.
+   */
+  cancelSearch: function() {
+    this._searching = false;
+    if (this._request) {
+      this._request.abort();
+      this._request = null;
+    }
+    this._callback = null;
+  },
+
+  /**
+   * Begins a search for add-ons in this repository by ID. Results will be
+   * passed to the given callback.
+   *
+   * @param  aIDs
+   *         The array of ids to search for
+   * @param  aCallback
+   *         The callback to pass results to
+   */
+  getAddonsByIDs: function(aIDs, aCallback) {
+    return this._beginGetAddons(aIDs, aCallback, false);
+  },
+
+  /**
+   * Begins a search of add-ons, potentially sending performance data.
+   *
+   * @param  aIDs
+   *         Array of ids to search for.
+   * @param  aCallback
+   *         Function to pass results to.
+   * @param  aSendPerformance
+   *         Boolean indicating whether to send performance data with the
+   *         request.
+   * @param  aTimeout
+   *         (Optional) timeout in milliseconds to abandon the XHR request
+   *         if we have not received a response from the server.
+   */
+  _beginGetAddons: function(aIDs, aCallback, aSendPerformance, aTimeout) {
+    let ids = aIDs.slice(0);
+
+    let params = {
+      API_VERSION : API_VERSION,
+      IDS : ids.map(encodeURIComponent).join(',')
+    };
+
+    let pref = PREF_GETADDONS_BYIDS;
+
+    if (aSendPerformance) {
+      let type = Services.prefs.getPrefType(PREF_GETADDONS_BYIDS_PERFORMANCE);
+      if (type == Services.prefs.PREF_STRING) {
+        pref = PREF_GETADDONS_BYIDS_PERFORMANCE;
+
+        let startupInfo = Cc["@mozilla.org/toolkit/app-startup;1"].
+                          getService(Ci.nsIAppStartup).
+                          getStartupInfo();
+
+        params.TIME_MAIN = "";
+        params.TIME_FIRST_PAINT = "";
+        params.TIME_SESSION_RESTORED = "";
+        if (startupInfo.process) {
+          if (startupInfo.main) {
+            params.TIME_MAIN = startupInfo.main - startupInfo.process;
+          }
+          if (startupInfo.firstPaint) {
+            params.TIME_FIRST_PAINT = startupInfo.firstPaint -
+                                      startupInfo.process;
+          }
+          if (startupInfo.sessionRestored) {
+            params.TIME_SESSION_RESTORED = startupInfo.sessionRestored -
+                                           startupInfo.process;
+          }
+        }
+      }
+    }
+
+    let url = this._formatURLPref(pref, params);
+
+    let  handleResults = (aElements, aTotalResults, aCompatData) => {
+      // Don't use this._parseAddons() so that, for example,
+      // incompatible add-ons are not filtered out
+      let results = [];
+      for (let i = 0; i < aElements.length && results.length < this._maxResults; i++) {
+        let result = this._parseAddon(aElements[i], null, aCompatData);
+        if (result == null)
+          continue;
+
+        // Ignore add-on if it wasn't actually requested
+        let idIndex = ids.indexOf(result.addon.id);
+        if (idIndex == -1)
+          continue;
+
+        // Ignore add-on if the add-on manager doesn't know about its type:
+        if (!(result.addon.type in AddonManager.addonTypes)) {
+          continue;
+        }
+
+        results.push(result);
+        // Ignore this add-on from now on
+        ids.splice(idIndex, 1);
+      }
+
+      // Include any compatibility overrides for addons not hosted by the
+      // remote repository.
+      for (let id in aCompatData) {
+        let addonCompat = aCompatData[id];
+        if (addonCompat.hosted)
+          continue;
+
+        let addon = new AddonSearchResult(addonCompat.id);
+        // Compatibility overrides can only be for extensions.
+        addon.type = "extension";
+        addon.compatibilityOverrides = addonCompat.compatRanges;
+        let result = {
+          addon: addon,
+          xpiURL: null,
+          xpiHash: null
+        };
+        results.push(result);
+      }
+
+      // aTotalResults irrelevant
+      this._reportSuccess(results, -1);
+    }
+
+    this._beginSearch(url, ids.length, aCallback, handleResults, aTimeout);
+  },
+
+  /**
+   * Performs the daily background update check.
+   *
+   * This API both searches for the add-on IDs specified and sends performance
+   * data. It is meant to be called as part of the daily update ping. It should
+   * not be used for any other purpose. Use repopulateCache instead.
+   *
+   * @return Promise{null} Resolves when the metadata update is complete.
+   */
+  backgroundUpdateCheck: function() {
+    return this._repopulateCacheInternal(true);
+  },
+
+  /**
+   * Begins a search for recommended add-ons in this repository. Results will
+   * be passed to the given callback.
+   *
+   * @param  aMaxResults
+   *         The maximum number of results to return
+   * @param  aCallback
+   *         The callback to pass results to
+   */
+  retrieveRecommendedAddons: function(aMaxResults, aCallback) {
+    let url = this._formatURLPref(PREF_GETADDONS_GETRECOMMENDED, {
+      API_VERSION : API_VERSION,
+
+      // Get twice as many results to account for potential filtering
+      MAX_RESULTS : 2 * aMaxResults
+    });
+
+    let handleResults = (aElements, aTotalResults) => {
+      this._getLocalAddonIds(aLocalAddonIds => {
+        // aTotalResults irrelevant
+        this._parseAddons(aElements, -1, aLocalAddonIds);
+      });
+    }
+
+    this._beginSearch(url, aMaxResults, aCallback, handleResults);
+  },
+
+  /**
+   * Begins a search for add-ons in this repository. Results will be passed to
+   * the given callback.
+   *
+   * @param  aSearchTerms
+   *         The terms to search for
+   * @param  aMaxResults
+   *         The maximum number of results to return
+   * @param  aCallback
+   *         The callback to pass results to
+   */
+  searchAddons: function(aSearchTerms, aMaxResults, aCallback) {
+    let compatMode = "normal";
+    if (!AddonManager.checkCompatibility)
+      compatMode = "ignore";
+    else if (AddonManager.strictCompatibility)
+      compatMode = "strict";
+
+    let substitutions = {
+      API_VERSION : API_VERSION,
+      TERMS : encodeURIComponent(aSearchTerms),
+      // Get twice as many results to account for potential filtering
+      MAX_RESULTS : 2 * aMaxResults,
+      COMPATIBILITY_MODE : compatMode,
+    };
+
+    let url = this._formatURLPref(PREF_GETADDONS_GETSEARCHRESULTS, substitutions);
+
+    let handleResults = (aElements, aTotalResults) => {
+      this._getLocalAddonIds(aLocalAddonIds => {
+        this._parseAddons(aElements, aTotalResults, aLocalAddonIds);
+      });
+    }
+
+    this._beginSearch(url, aMaxResults, aCallback, handleResults);
+  },
+
+  // Posts results to the callback
+  _reportSuccess: function(aResults, aTotalResults) {
+    this._searching = false;
+    this._request = null;
+    // The callback may want to trigger a new search so clear references early
+    let addons = aResults.map(result => result.addon);
+    let callback = this._callback;
+    this._callback = null;
+    callback.searchSucceeded(addons, addons.length, aTotalResults);
+  },
+
+  // Notifies the callback of a failure
+  _reportFailure: function() {
+    this._searching = false;
+    this._request = null;
+    // The callback may want to trigger a new search so clear references early
+    let callback = this._callback;
+    this._callback = null;
+    callback.searchFailed();
+  },
+
+  // Get descendant by unique tag name. Returns null if not unique tag name.
+  _getUniqueDescendant: function(aElement, aTagName) {
+    let elementsList = aElement.getElementsByTagName(aTagName);
+    return (elementsList.length == 1) ? elementsList[0] : null;
+  },
+
+  // Get direct descendant by unique tag name.
+  // Returns null if not unique tag name.
+  _getUniqueDirectDescendant: function(aElement, aTagName) {
+    let elementsList = Array.filter(aElement.children,
+                                    aChild => aChild.tagName == aTagName);
+    return (elementsList.length == 1) ? elementsList[0] : null;
+  },
+
+  // Parse out trimmed text content. Returns null if text content empty.
+  _getTextContent: function(aElement) {
+    let textContent = aElement.textContent.trim();
+    return (textContent.length > 0) ? textContent : null;
+  },
+
+  // Parse out trimmed text content of a descendant with the specified tag name
+  // Returns null if the parsing unsuccessful.
+  _getDescendantTextContent: function(aElement, aTagName) {
+    let descendant = this._getUniqueDescendant(aElement, aTagName);
+    return (descendant != null) ? this._getTextContent(descendant) : null;
+  },
+
+  // Parse out trimmed text content of a direct descendant with the specified
+  // tag name.
+  // Returns null if the parsing unsuccessful.
+  _getDirectDescendantTextContent: function(aElement, aTagName) {
+    let descendant = this._getUniqueDirectDescendant(aElement, aTagName);
+    return (descendant != null) ? this._getTextContent(descendant) : null;
+  },
+
+  /*
+   * Creates an AddonSearchResult by parsing an <addon> element
+   *
+   * @param  aElement
+   *         The <addon> element to parse
+   * @param  aSkip
+   *         Object containing ids and sourceURIs of add-ons to skip.
+   * @param  aCompatData
+   *         Array of parsed addon_compatibility elements to accosiate with the
+   *         resulting AddonSearchResult. Optional.
+   * @return Result object containing the parsed AddonSearchResult, xpiURL and
+   *         xpiHash if the parsing was successful. Otherwise returns null.
+   */
+  _parseAddon: function(aElement, aSkip, aCompatData) {
+    let skipIDs = (aSkip && aSkip.ids) ? aSkip.ids : [];
+    let skipSourceURIs = (aSkip && aSkip.sourceURIs) ? aSkip.sourceURIs : [];
+
+    let guid = this._getDescendantTextContent(aElement, "guid");
+    if (guid == null || skipIDs.indexOf(guid) != -1)
+      return null;
+
+    let addon = new AddonSearchResult(guid);
+    let result = {
+      addon: addon,
+      xpiURL: null,
+      xpiHash: null
+    };
+
+    if (aCompatData && guid in aCompatData)
+      addon.compatibilityOverrides = aCompatData[guid].compatRanges;
+
+    for (let node = aElement.firstChild; node; node = node.nextSibling) {
+      if (!(node instanceof Ci.nsIDOMElement))
+        continue;
+
+      let localName = node.localName;
+
+      // Handle case where the wanted string value is located in text content
+      // but only if the content is not empty
+      if (localName in STRING_KEY_MAP) {
+        addon[STRING_KEY_MAP[localName]] = this._getTextContent(node) || addon[STRING_KEY_MAP[localName]];
+        continue;
+      }
+
+      // Handle case where the wanted string value is html located in text content
+      if (localName in HTML_KEY_MAP) {
+        addon[HTML_KEY_MAP[localName]] = convertHTMLToPlainText(this._getTextContent(node));
+        continue;
+      }
+
+      // Handle case where the wanted integer value is located in text content
+      if (localName in INTEGER_KEY_MAP) {
+        let value = parseInt(this._getTextContent(node));
+        if (value >= 0)
+          addon[INTEGER_KEY_MAP[localName]] = value;
+        continue;
+      }
+
+      // Handle cases that aren't as simple as grabbing the text content
+      switch (localName) {
+        case "type":
+          // Map AMO's type id to corresponding string
+          // https://github.com/mozilla/olympia/blob/master/apps/constants/base.py#L127
+          // These definitions need to be updated whenever AMO adds a new type.
+          let id = parseInt(node.getAttribute("id"));
+          switch (id) {
+            case 1:
+              addon.type = "extension";
+              break;
+            case 2:
+              addon.type = "theme";
+              break;
+            case 3:
+              addon.type = "dictionary";
+              break;
+            case 4:
+              addon.type = "search";
+              break;
+            case 5:
+            case 6:
+              addon.type = "locale";
+              break;
+            case 7:
+              addon.type = "plugin";
+              break;
+            case 8:
+              addon.type = "api";
+              break;
+            case 9:
+              addon.type = "lightweight-theme";
+              break;
+            case 11:
+              addon.type = "webapp";
+              break;
+            default:
+              logger.info("Unknown type id " + id + " found when parsing response for GUID " + guid);
+          }
+          break;
+        case "authors":
+          let authorNodes = node.getElementsByTagName("author");
+          for (let authorNode of authorNodes) {
+            let name = this._getDescendantTextContent(authorNode, "name");
+            let link = this._getDescendantTextContent(authorNode, "link");
+            if (name == null || link == null)
+              continue;
+
+            let author = new AddonManagerPrivate.AddonAuthor(name, link);
+            if (addon.creator == null)
+              addon.creator = author;
+            else {
+              if (addon.developers == null)
+                addon.developers = [];
+
+              addon.developers.push(author);
+            }
+          }
+          break;
+        case "previews":
+          let previewNodes = node.getElementsByTagName("preview");
+          for (let previewNode of previewNodes) {
+            let full = this._getUniqueDescendant(previewNode, "full");
+            if (full == null)
+              continue;
+
+            let fullURL = this._getTextContent(full);
+            let fullWidth = full.getAttribute("width");
+            let fullHeight = full.getAttribute("height");
+
+            let thumbnailURL, thumbnailWidth, thumbnailHeight;
+            let thumbnail = this._getUniqueDescendant(previewNode, "thumbnail");
+            if (thumbnail) {
+              thumbnailURL = this._getTextContent(thumbnail);
+              thumbnailWidth = thumbnail.getAttribute("width");
+              thumbnailHeight = thumbnail.getAttribute("height");
+            }
+            let caption = this._getDescendantTextContent(previewNode, "caption");
+            let screenshot = new AddonManagerPrivate.AddonScreenshot(fullURL, fullWidth, fullHeight,
+                                                                     thumbnailURL, thumbnailWidth,
+                                                                     thumbnailHeight, caption);
+
+            if (addon.screenshots == null)
+              addon.screenshots = [];
+
+            if (previewNode.getAttribute("primary") == 1)
+              addon.screenshots.unshift(screenshot);
+            else
+              addon.screenshots.push(screenshot);
+          }
+          break;
+        case "learnmore":
+          addon.learnmoreURL = this._getTextContent(node);
+          addon.homepageURL = addon.homepageURL || addon.learnmoreURL;
+          break;
+        case "contribution_data":
+          let meetDevelopers = this._getDescendantTextContent(node, "meet_developers");
+          let suggestedAmount = this._getDescendantTextContent(node, "suggested_amount");
+          if (meetDevelopers != null) {
+            addon.contributionURL = meetDevelopers;
+            addon.contributionAmount = suggestedAmount;
+          }
+          break
+        case "payment_data":
+          let link = this._getDescendantTextContent(node, "link");
+          let amountTag = this._getUniqueDescendant(node, "amount");
+          let amount = parseFloat(amountTag.getAttribute("amount"));
+          let displayAmount = this._getTextContent(amountTag);
+          if (link != null && amount != null && displayAmount != null) {
+            addon.purchaseURL = link;
+            addon.purchaseAmount = amount;
+            addon.purchaseDisplayAmount = displayAmount;
+          }
+          break
+        case "rating":
+          let averageRating = parseInt(this._getTextContent(node));
+          if (averageRating >= 0)
+            addon.averageRating = Math.min(5, averageRating);
+          break;
+        case "reviews":
+          let url = this._getTextContent(node);
+          let num = parseInt(node.getAttribute("num"));
+          if (url != null && num >= 0) {
+            addon.reviewURL = url;
+            addon.reviewCount = num;
+          }
+          break;
+        case "status":
+          let repositoryStatus = parseInt(node.getAttribute("id"));
+          if (!isNaN(repositoryStatus))
+            addon.repositoryStatus = repositoryStatus;
+          break;
+        case "all_compatible_os":
+          let nodes = node.getElementsByTagName("os");
+          addon.isPlatformCompatible = Array.some(nodes, function(aNode) {
+            let text = aNode.textContent.toLowerCase().trim();
+            return text == "all" || text == Services.appinfo.OS.toLowerCase();
+          });
+          break;
+        case "install":
+          // No os attribute means the xpi is compatible with any os
+          if (node.hasAttribute("os")) {
+            let os = node.getAttribute("os").trim().toLowerCase();
+            // If the os is not ALL and not the current OS then ignore this xpi
+            if (os != "all" && os != Services.appinfo.OS.toLowerCase())
+              break;
+          }
+
+          let xpiURL = this._getTextContent(node);
+          if (xpiURL == null)
+            break;
+
+          if (skipSourceURIs.indexOf(xpiURL) != -1)
+            return null;
+
+          result.xpiURL = xpiURL;
+          addon.sourceURI = NetUtil.newURI(xpiURL);
+
+          let size = parseInt(node.getAttribute("size"));
+          addon.size = (size >= 0) ? size : null;
+
+          let xpiHash = node.getAttribute("hash");
+          if (xpiHash != null)
+            xpiHash = xpiHash.trim();
+          result.xpiHash = xpiHash ? xpiHash : null;
+          break;
+        case "last_updated":
+          let epoch = parseInt(node.getAttribute("epoch"));
+          if (!isNaN(epoch))
+            addon.updateDate = new Date(1000 * epoch);
+          break;
+        case "icon":
+          addon.icons[node.getAttribute("size")] = this._getTextContent(node);
+          break;
+      }
+    }
+
+    return result;
+  },
+
+  _parseAddons: function(aElements, aTotalResults, aSkip) {
+    let results = [];
+
+    let isSameApplication = aAppNode => this._getTextContent(aAppNode) == Services.appinfo.ID;
+
+    for (let i = 0; i < aElements.length && results.length < this._maxResults; i++) {
+      let element = aElements[i];
+
+      let tags = this._getUniqueDescendant(element, "compatible_applications");
+      if (tags == null)
+        continue;
+
+      let applications = tags.getElementsByTagName("appID");
+      let compatible = Array.some(applications, aAppNode => {
+        if (!isSameApplication(aAppNode))
+          return false;
+
+        let parent = aAppNode.parentNode;
+        let minVersion = this._getDescendantTextContent(parent, "min_version");
+        let maxVersion = this._getDescendantTextContent(parent, "max_version");
+        if (minVersion == null || maxVersion == null)
+          return false;
+
+        let currentVersion = Services.appinfo.version;
+        return (Services.vc.compare(minVersion, currentVersion) <= 0 &&
+                ((!AddonManager.strictCompatibility) ||
+                 Services.vc.compare(currentVersion, maxVersion) <= 0));
+      });
+
+      // Ignore add-ons not compatible with this Application
+      if (!compatible) {
+        if (AddonManager.checkCompatibility)
+          continue;
+
+        if (!Array.some(applications, isSameApplication))
+          continue;
+      }
+
+      // Add-on meets all requirements, so parse out data.
+      // Don't pass in compatiblity override data, because that's only returned
+      // in GUID searches, which don't use _parseAddons().
+      let result = this._parseAddon(element, aSkip);
+      if (result == null)
+        continue;
+
+      // Ignore add-on missing a required attribute
+      let requiredAttributes = ["id", "name", "version", "type", "creator"];
+      if (requiredAttributes.some(aAttribute => !result.addon[aAttribute]))
+        continue;
+
+      // Ignore add-on with a type AddonManager doesn't understand:
+      if (!(result.addon.type in AddonManager.addonTypes))
+        continue;
+
+      // Add only if the add-on is compatible with the platform
+      if (!result.addon.isPlatformCompatible)
+        continue;
+
+      // Add only if there was an xpi compatible with this OS or there was a
+      // way to purchase the add-on
+      if (!result.xpiURL && !result.addon.purchaseURL)
+        continue;
+
+      result.addon.isCompatible = compatible;
+
+      results.push(result);
+      // Ignore this add-on from now on by adding it to the skip array
+      aSkip.ids.push(result.addon.id);
+    }
+
+    // Immediately report success if no AddonInstall instances to create
+    let pendingResults = results.length;
+    if (pendingResults == 0) {
+      this._reportSuccess(results, aTotalResults);
+      return;
+    }
+
+    // Create an AddonInstall for each result
+    for (let result of results) {
+      let addon = result.addon;
+      let callback = aInstall => {
+        addon.install = aInstall;
+        pendingResults--;
+        if (pendingResults == 0)
+          this._reportSuccess(results, aTotalResults);
+      }
+
+      if (result.xpiURL) {
+        AddonManager.getInstallForURL(result.xpiURL, callback,
+                                      "application/x-xpinstall", result.xpiHash,
+                                      addon.name, addon.icons, addon.version);
+      }
+      else {
+        callback(null);
+      }
+    }
+  },
+
+  // Parses addon_compatibility nodes, that describe compatibility overrides.
+  _parseAddonCompatElement: function(aResultObj, aElement) {
+    let guid = this._getDescendantTextContent(aElement, "guid");
+    if (!guid) {
+        logger.debug("Compatibility override is missing guid.");
+      return;
+    }
+
+    let compat = {id: guid};
+    compat.hosted = aElement.getAttribute("hosted") != "false";
+
+    function findMatchingAppRange(aNodes) {
+      let toolkitAppRange = null;
+      for (let node of aNodes) {
+        let appID = this._getDescendantTextContent(node, "appID");
+        if (appID != Services.appinfo.ID && appID != TOOLKIT_ID)
+          continue;
+
+        let minVersion = this._getDescendantTextContent(node, "min_version");
+        let maxVersion = this._getDescendantTextContent(node, "max_version");
+        if (minVersion == null || maxVersion == null)
+          continue;
+
+        let appRange = { appID: appID,
+                         appMinVersion: minVersion,
+                         appMaxVersion: maxVersion };
+
+        // Only use Toolkit app ranges if no ranges match the application ID.
+        if (appID == TOOLKIT_ID)
+          toolkitAppRange = appRange;
+        else
+          return appRange;
+      }
+      return toolkitAppRange;
+    }
+
+    function parseRangeNode(aNode) {
+      let type = aNode.getAttribute("type");
+      // Only "incompatible" (blacklisting) is supported for now.
+      if (type != "incompatible") {
+        logger.debug("Compatibility override of unsupported type found.");
+        return null;
+      }
+
+      let override = new AddonManagerPrivate.AddonCompatibilityOverride(type);
+
+      override.minVersion = this._getDirectDescendantTextContent(aNode, "min_version");
+      override.maxVersion = this._getDirectDescendantTextContent(aNode, "max_version");
+
+      if (!override.minVersion) {
+        logger.debug("Compatibility override is missing min_version.");
+        return null;
+      }
+      if (!override.maxVersion) {
+        logger.debug("Compatibility override is missing max_version.");
+        return null;
+      }
+
+      let appRanges = aNode.querySelectorAll("compatible_applications > application");
+      let appRange = findMatchingAppRange.bind(this)(appRanges);
+      if (!appRange) {
+        logger.debug("Compatibility override is missing a valid application range.");
+        return null;
+      }
+
+      override.appID = appRange.appID;
+      override.appMinVersion = appRange.appMinVersion;
+      override.appMaxVersion = appRange.appMaxVersion;
+
+      return override;
+    }
+
+    let rangeNodes = aElement.querySelectorAll("version_ranges > version_range");
+    compat.compatRanges = Array.map(rangeNodes, parseRangeNode.bind(this))
+                               .filter(aItem => !!aItem);
+    if (compat.compatRanges.length == 0)
+      return;
+
+    aResultObj[compat.id] = compat;
+  },
+
+  // Parses addon_compatibility elements.
+  _parseAddonCompatData: function(aElements) {
+    let compatData = {};
+    Array.forEach(aElements, this._parseAddonCompatElement.bind(this, compatData));
+    return compatData;
+  },
+
+  // Begins a new search if one isn't currently executing
+  _beginSearch: function(aURI, aMaxResults, aCallback, aHandleResults, aTimeout) {
+    if (this._searching || aURI == null || aMaxResults <= 0) {
+      logger.warn("AddonRepository search failed: searching " + this._searching + " aURI " + aURI +
+                  " aMaxResults " + aMaxResults);
+      aCallback.searchFailed();
+      return;
+    }
+
+    this._searching = true;
+    this._callback = aCallback;
+    this._maxResults = aMaxResults;
+
+    logger.debug("Requesting " + aURI);
+
+    this._request = new ServiceRequest();
+    this._request.mozBackgroundRequest = true;
+    this._request.open("GET", aURI, true);
+    this._request.overrideMimeType("text/xml");
+    if (aTimeout) {
+      this._request.timeout = aTimeout;
+    }
+
+    this._request.addEventListener("error", aEvent => this._reportFailure(), false);
+    this._request.addEventListener("timeout", aEvent => this._reportFailure(), false);
+    this._request.addEventListener("load", aEvent => {
+      logger.debug("Got metadata search load event");
+      let request = aEvent.target;
+      let responseXML = request.responseXML;
+
+      if (!responseXML || responseXML.documentElement.namespaceURI == XMLURI_PARSE_ERROR ||
+          (request.status != 200 && request.status != 0)) {
+        this._reportFailure();
+        return;
+      }
+
+      let documentElement = responseXML.documentElement;
+      let elements = documentElement.getElementsByTagName("addon");
+      let totalResults = elements.length;
+      let parsedTotalResults = parseInt(documentElement.getAttribute("total_results"));
+      // Parsed value of total results only makes sense if >= elements.length
+      if (parsedTotalResults >= totalResults)
+        totalResults = parsedTotalResults;
+
+      let compatElements = documentElement.getElementsByTagName("addon_compatibility");
+      let compatData = this._parseAddonCompatData(compatElements);
+
+      aHandleResults(elements, totalResults, compatData);
+    }, false);
+    this._request.send(null);
+  },
+
+  // Gets the id's of local add-ons, and the sourceURI's of local installs,
+  // passing the results to aCallback
+  _getLocalAddonIds: function(aCallback) {
+    let localAddonIds = {ids: null, sourceURIs: null};
+
+    AddonManager.getAllAddons(function(aAddons) {
+      localAddonIds.ids = aAddons.map(a => a.id);
+      if (localAddonIds.sourceURIs)
+        aCallback(localAddonIds);
+    });
+
+    AddonManager.getAllInstalls(function(aInstalls) {
+      localAddonIds.sourceURIs = [];
+      for (let install of aInstalls) {
+        if (install.state != AddonManager.STATE_AVAILABLE)
+          localAddonIds.sourceURIs.push(install.sourceURI.spec);
+      }
+
+      if (localAddonIds.ids)
+        aCallback(localAddonIds);
+    });
+  },
+
+  // Create url from preference, returning null if preference does not exist
+  _formatURLPref: function(aPreference, aSubstitutions) {
+    let url = null;
+    try {
+      url = Services.prefs.getCharPref(aPreference);
+    } catch (e) {
+      logger.warn("_formatURLPref: Couldn't get pref: " + aPreference);
+      return null;
+    }
+
+    url = url.replace(/%([A-Z_]+)%/g, function(aMatch, aKey) {
+      return (aKey in aSubstitutions) ? aSubstitutions[aKey] : aMatch;
+    });
+
+    return Services.urlFormatter.formatURL(url);
+  },
+
+  // Find a AddonCompatibilityOverride that matches a given aAddonVersion and
+  // application/platform version.
+  findMatchingCompatOverride: function(aAddonVersion,
+                                                                     aCompatOverrides,
+                                                                     aAppVersion,
+                                                                     aPlatformVersion) {
+    for (let override of aCompatOverrides) {
+
+      let appVersion = null;
+      if (override.appID == TOOLKIT_ID)
+        appVersion = aPlatformVersion || Services.appinfo.platformVersion;
+      else
+        appVersion = aAppVersion || Services.appinfo.version;
+
+      if (Services.vc.compare(override.minVersion, aAddonVersion) <= 0 &&
+          Services.vc.compare(aAddonVersion, override.maxVersion) <= 0 &&
+          Services.vc.compare(override.appMinVersion, appVersion) <= 0 &&
+          Services.vc.compare(appVersion, override.appMaxVersion) <= 0) {
+        return override;
+      }
+    }
+    return null;
+  },
+
+  flush: function() {
+    return AddonDatabase.flush();
+  }
+};
+
+var AddonDatabase = {
+  connectionPromise: null,
+  // the in-memory database
+  DB: BLANK_DB(),
+
+  /**
+   * A getter to retrieve the path to the DB
+   */
+  get jsonFile() {
+    return OS.Path.join(OS.Constants.Path.profileDir, FILE_DATABASE);
+ },
+
+  /**
+   * Asynchronously opens a new connection to the database file.
+   *
+   * @return {Promise} a promise that resolves to the database.
+   */
+  openConnection: function() {
+    if (!this.connectionPromise) {
+     this.connectionPromise = Task.spawn(function*() {
+       this.DB = BLANK_DB();
+
+       let inputDB, schema;
+
+       try {
+         let data = yield OS.File.read(this.jsonFile, { encoding: "utf-8"})
+         inputDB = JSON.parse(data);
+
+         if (!inputDB.hasOwnProperty("addons") ||
+             !Array.isArray(inputDB.addons)) {
+           throw new Error("No addons array.");
+         }
+
+         if (!inputDB.hasOwnProperty("schema")) {
+           throw new Error("No schema specified.");
+         }
+
+         schema = parseInt(inputDB.schema, 10);
+
+         if (!Number.isInteger(schema) ||
+             schema < DB_MIN_JSON_SCHEMA) {
+           throw new Error("Invalid schema value.");
+         }
+       } catch (e) {
+         if (e instanceof OS.File.Error && e.becauseNoSuchFile) {
+           logger.debug("No " + FILE_DATABASE + " found.");
+         } else {
+           logger.error(`Malformed ${FILE_DATABASE}: ${e} - resetting to empty`);
+         }
+
+         // Create a blank addons.json file
+         this._saveDBToDisk();
+
+         let dbSchema = 0;
+         try {
+           dbSchema = Services.prefs.getIntPref(PREF_GETADDONS_DB_SCHEMA);
+         } catch (e) {}
+
+         if (dbSchema < DB_MIN_JSON_SCHEMA) {
+           let results = yield new Promise((resolve, reject) => {
+             AddonRepository_SQLiteMigrator.migrate(resolve);
+           });
+
+           if (results.length) {
+             yield this._insertAddons(results);
+           }
+
+         }
+
+         Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA);
+         return this.DB;
+       }
+
+       Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA);
+
+       // We use _insertAddon manually instead of calling
+       // insertAddons to avoid the write to disk which would
+       // be a waste since this is the data that was just read.
+       for (let addon of inputDB.addons) {
+         this._insertAddon(addon);
+       }
+
+       return this.DB;
+     }.bind(this));
+    }
+
+    return this.connectionPromise;
+  },
+
+  /**
+   * A lazy getter for the database connection.
+   */
+  get connection() {
+    return this.openConnection();
+  },
+
+  /**
+   * Asynchronously shuts down the database connection and releases all
+   * cached objects
+   *
+   * @param  aCallback
+   *         An optional callback to call once complete
+   * @param  aSkipFlush
+   *         An optional boolean to skip flushing data to disk. Useful
+   *         when the database is going to be deleted afterwards.
+   */
+  shutdown: function(aSkipFlush) {
+    if (!this.connectionPromise) {
+      return Promise.resolve();
+    }
+
+    this.connectionPromise = null;
+
+    if (aSkipFlush) {
+      return Promise.resolve();
+    }
+    return this.Writer.flush();
+  },
+
+  /**
+   * Asynchronously deletes the database, shutting down the connection
+   * first if initialized
+   *
+   * @param  aCallback
+   *         An optional callback to call once complete
+   * @return Promise{null} resolves when the database has been deleted
+   */
+  delete: function(aCallback) {
+    this.DB = BLANK_DB();
+
+    this._deleting = this.Writer.flush()
+      .then(null, () => {})
+      // shutdown(true) never rejects
+      .then(() => this.shutdown(true))
+      .then(() => OS.File.remove(this.jsonFile, {}))
+      .then(null, error => logger.error("Unable to delete Addon Repository file " +
+                                 this.jsonFile, error))
+      .then(() => this._deleting = null)
+      .then(aCallback);
+    return this._deleting;
+  },
+
+  toJSON: function() {
+    let json = {
+      schema: this.DB.schema,
+      addons: []
+    }
+
+    for (let [, value] of this.DB.addons)
+      json.addons.push(value);
+
+    return json;
+  },
+
+  /*
+   * This is a deferred task writer that is used
+   * to batch operations done within 50ms of each
+   * other and thus generating only one write to disk
+   */
+  get Writer() {
+    delete this.Writer;
+    this.Writer = new DeferredSave(
+      this.jsonFile,
+      () => { return JSON.stringify(this); },
+      DB_BATCH_TIMEOUT_MS
+    );
+    return this.Writer;
+  },
+
+  /**
+   * Flush any pending I/O on the addons.json file
+   * @return: Promise{null}
+   *          Resolves when the pending I/O (writing out or deleting
+   *          addons.json) completes
+   */
+  flush: function() {
+    if (this._deleting) {
+      return this._deleting;
+    }
+    return this.Writer.flush();
+  },
+
+  /**
+   * Asynchronously retrieve all add-ons from the database
+   * @return: Promise{Map}
+   *          Resolves when the add-ons are retrieved from the database
+   */
+  retrieveStoredData: function() {
+    return this.openConnection().then(db => db.addons);
+  },
+
+  /**
+   * Asynchronously repopulates the database so it only contains the
+   * specified add-ons
+   *
+   * @param  aAddons
+   *         The array of add-ons to repopulate the database with
+   * @param  aCallback
+   *         An optional callback to call once complete
+   */
+  repopulate: function(aAddons, aCallback) {
+    this.DB.addons.clear();
+    this.insertAddons(aAddons, function() {
+      let now = Math.round(Date.now() / 1000);
+      logger.debug("Cache repopulated, setting " + PREF_METADATA_LASTUPDATE + " to " + now);
+      Services.prefs.setIntPref(PREF_METADATA_LASTUPDATE, now);
+      if (aCallback)
+        aCallback();
+    });
+  },
+
+  /**
+   * Asynchronously inserts an array of add-ons into the database
+   *
+   * @param  aAddons
+   *         The array of add-ons to insert
+   * @param  aCallback
+   *         An optional callback to call once complete
+   */
+  insertAddons: Task.async(function*(aAddons, aCallback) {
+    yield this.openConnection();
+    yield this._insertAddons(aAddons, aCallback);
+  }),
+
+  _insertAddons: Task.async(function*(aAddons, aCallback) {
+    for (let addon of aAddons) {
+      this._insertAddon(addon);
+    }
+
+    yield this._saveDBToDisk();
+    aCallback && aCallback();
+  }),
+
+  /**
+   * Inserts an individual add-on into the database. If the add-on already
+   * exists in the database (by id), then the specified add-on will not be
+   * inserted.
+   *
+   * @param  aAddon
+   *         The add-on to insert into the database
+   * @param  aCallback
+   *         The callback to call once complete
+   */
+  _insertAddon: function(aAddon) {
+    let newAddon = this._parseAddon(aAddon);
+    if (!newAddon ||
+        !newAddon.id ||
+        this.DB.addons.has(newAddon.id))
+      return;
+
+    this.DB.addons.set(newAddon.id, newAddon);
+  },
+
+  /*
+   * Creates an AddonSearchResult by parsing an object structure
+   * retrieved from the DB JSON representation.
+   *
+   * @param  aObj
+   *         The object to parse
+   * @return Returns an AddonSearchResult object.
+   */
+  _parseAddon: function(aObj) {
+    if (aObj instanceof AddonSearchResult)
+      return aObj;
+
+    let id = aObj.id;
+    if (!aObj.id)
+      return null;
+
+    let addon = new AddonSearchResult(id);
+
+    for (let expectedProperty of Object.keys(AddonSearchResult.prototype)) {
+      if (!(expectedProperty in aObj) ||
+          typeof(aObj[expectedProperty]) === "function")
+        continue;
+
+      let value = aObj[expectedProperty];
+
+      try {
+        switch (expectedProperty) {
+          case "sourceURI":
+            addon.sourceURI = value ? NetUtil.newURI(value) :  null;
+            break;
+
+          case "creator":
+            addon.creator = value
+                            ? this._makeDeveloper(value)
+                            : null;
+            break;
+
+          case "updateDate":
+            addon.updateDate = value ? new Date(value) : null;
+            break;
+
+          case "developers":
+            if (!addon.developers) addon.developers = [];
+            for (let developer of value) {
+              addon.developers.push(this._makeDeveloper(developer));
+            }
+            break;
+
+          case "screenshots":
+            if (!addon.screenshots) addon.screenshots = [];
+            for (let screenshot of value) {
+              addon.screenshots.push(this._makeScreenshot(screenshot));
+            }
+            break;
+
+          case "compatibilityOverrides":
+            if (!addon.compatibilityOverrides) addon.compatibilityOverrides = [];
+            for (let override of value) {
+              addon.compatibilityOverrides.push(
+                this._makeCompatOverride(override)
+              );
+            }
+            break;
+
+          case "icons":
+            if (!addon.icons) addon.icons = {};
+            for (let size of Object.keys(aObj.icons)) {
+              addon.icons[size] = aObj.icons[size];
+            }
+            break;
+
+          case "iconURL":
+            break;
+
+          default:
+            addon[expectedProperty] = value;
+        }
+      } catch (ex) {
+        logger.warn("Error in parsing property value for " + expectedProperty + " | " + ex);
+      }
+
+      // delete property from obj to indicate we've already
+      // handled it. The remaining public properties will
+      // be stored separately and just passed through to
+      // be written back to the DB.
+      delete aObj[expectedProperty];
+    }
+
+    // Copy remaining properties to a separate object
+    // to prevent accidental access on downgraded versions.
+    // The properties will be merged in the same object
+    // prior to being written back through toJSON.
+    for (let remainingProperty of Object.keys(aObj)) {
+      switch (typeof(aObj[remainingProperty])) {
+        case "boolean":
+        case "number":
+        case "string":
+        case "object":
+          // these types are accepted
+          break;
+        default:
+          continue;
+      }
+
+      if (!remainingProperty.startsWith("_"))
+        addon._unsupportedProperties[remainingProperty] =
+          aObj[remainingProperty];
+    }
+
+    return addon;
+  },
+
+  /**
+   * Write the in-memory DB to disk, after waiting for
+   * the DB_BATCH_TIMEOUT_MS timeout.
+   *
+   * @return Promise A promise that resolves after the
+   *                 write to disk has completed.
+   */
+  _saveDBToDisk: function() {
+    return this.Writer.saveChanges().then(
+      null,
+      e => logger.error("SaveDBToDisk failed", e));
+  },
+
+  /**
+   * Make a developer object from a vanilla
+   * JS object from the JSON database
+   *
+   * @param  aObj
+   *         The JS object to use
+   * @return The created developer
+   */
+  _makeDeveloper: function(aObj) {
+    let name = aObj.name;
+    let url = aObj.url;
+    return new AddonManagerPrivate.AddonAuthor(name, url);
+  },
+
+  /**
+   * Make a screenshot object from a vanilla
+   * JS object from the JSON database
+   *
+   * @param  aObj
+   *         The JS object to use
+   * @return The created screenshot
+   */
+  _makeScreenshot: function(aObj) {
+    let url = aObj.url;
+    let width = aObj.width;
+    let height = aObj.height;
+    let thumbnailURL = aObj.thumbnailURL;
+    let thumbnailWidth = aObj.thumbnailWidth;
+    let thumbnailHeight = aObj.thumbnailHeight;
+    let caption = aObj.caption;
+    return new AddonManagerPrivate.AddonScreenshot(url, width, height, thumbnailURL,
+                                                   thumbnailWidth, thumbnailHeight, caption);
+  },
+
+  /**
+   * Make a CompatibilityOverride from a vanilla
+   * JS object from the JSON database
+   *
+   * @param  aObj
+   *         The JS object to use
+   * @return The created CompatibilityOverride
+   */
+  _makeCompatOverride: function(aObj) {
+    let type = aObj.type;
+    let minVersion = aObj.minVersion;
+    let maxVersion = aObj.maxVersion;
+    let appID = aObj.appID;
+    let appMinVersion = aObj.appMinVersion;
+    let appMaxVersion = aObj.appMaxVersion;
+    return new AddonManagerPrivate.AddonCompatibilityOverride(type,
+                                                              minVersion,
+                                                              maxVersion,
+                                                              appID,
+                                                              appMinVersion,
+                                                              appMaxVersion);
+  },
+};
diff --git a/toolkit/mozapps/webextensions/internal/AddonRepository_SQLiteMigrator.jsm b/toolkit/mozapps/webextensions/internal/AddonRepository_SQLiteMigrator.jsm
new file mode 100644
index 000000000..e3479643b
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonRepository_SQLiteMigrator.jsm
@@ -0,0 +1,522 @@
+/* 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 Cu = Components.utils;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/AddonManager.jsm");
+/* globals AddonManagerPrivate*/
+Cu.import("resource://gre/modules/FileUtils.jsm");
+
+const KEY_PROFILEDIR  = "ProfD";
+const FILE_DATABASE   = "addons.sqlite";
+const LAST_DB_SCHEMA   = 4;
+
+// Add-on properties present in the columns of the database
+const PROP_SINGLE = ["id", "type", "name", "version", "creator", "description",
+                     "fullDescription", "developerComments", "eula",
+                     "homepageURL", "supportURL", "contributionURL",
+                     "contributionAmount", "averageRating", "reviewCount",
+                     "reviewURL", "totalDownloads", "weeklyDownloads",
+                     "dailyUsers", "sourceURI", "repositoryStatus", "size",
+                     "updateDate"];
+
+Cu.import("resource://gre/modules/Log.jsm");
+const LOGGER_ID = "addons.repository.sqlmigrator";
+
+// Create a new logger for use by the Addons Repository SQL Migrator
+// (Requires AddonManager.jsm)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+this.EXPORTED_SYMBOLS = ["AddonRepository_SQLiteMigrator"];
+
+
+this.AddonRepository_SQLiteMigrator = {
+
+  /**
+   * Migrates data from a previous SQLite version of the
+   * database to the JSON version.
+   *
+   * @param structFunctions an object that contains functions
+   *                        to create the various objects used
+   *                        in the new JSON format
+   * @param aCallback       A callback to be called when migration
+   *                        finishes, with the results in an array
+   * @returns bool          True if a migration will happen (DB was
+   *                        found and succesfully opened)
+   */
+  migrate: function(aCallback) {
+    if (!this._openConnection()) {
+      this._closeConnection();
+      aCallback([]);
+      return false;
+    }
+
+    logger.debug("Importing addon repository from previous " + FILE_DATABASE + " storage.");
+
+    this._retrieveStoredData((results) => {
+      this._closeConnection();
+      let resultArray = Object.keys(results).map(k => results[k]);
+      logger.debug(resultArray.length + " addons imported.")
+      aCallback(resultArray);
+    });
+
+    return true;
+  },
+
+  /**
+   * Synchronously opens a new connection to the database file.
+   *
+   * @return bool           Whether the DB was opened successfully.
+   */
+  _openConnection: function() {
+    delete this.connection;
+
+    let dbfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true);
+    if (!dbfile.exists())
+      return false;
+
+    try {
+      this.connection = Services.storage.openUnsharedDatabase(dbfile);
+    } catch (e) {
+      return false;
+    }
+
+    this.connection.executeSimpleSQL("PRAGMA locking_mode = EXCLUSIVE");
+
+    // Any errors in here should rollback
+    try {
+      this.connection.beginTransaction();
+
+      switch (this.connection.schemaVersion) {
+        case 0:
+          return false;
+
+        case 1:
+          logger.debug("Upgrading database schema to version 2");
+          this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN width INTEGER");
+          this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN height INTEGER");
+          this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN thumbnailWidth INTEGER");
+          this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN thumbnailHeight INTEGER");
+        case 2:
+          logger.debug("Upgrading database schema to version 3");
+          this.connection.createTable("compatibility_override",
+                                      "addon_internal_id INTEGER, " +
+                                      "num INTEGER, " +
+                                      "type TEXT, " +
+                                      "minVersion TEXT, " +
+                                      "maxVersion TEXT, " +
+                                      "appID TEXT, " +
+                                      "appMinVersion TEXT, " +
+                                      "appMaxVersion TEXT, " +
+                                      "PRIMARY KEY (addon_internal_id, num)");
+        case 3:
+          logger.debug("Upgrading database schema to version 4");
+          this.connection.createTable("icon",
+                                      "addon_internal_id INTEGER, " +
+                                      "size INTEGER, " +
+                                      "url TEXT, " +
+                                      "PRIMARY KEY (addon_internal_id, size)");
+          this._createIndices();
+          this._createTriggers();
+          this.connection.schemaVersion = LAST_DB_SCHEMA;
+        case LAST_DB_SCHEMA:
+          break;
+        default:
+          return false;
+      }
+      this.connection.commitTransaction();
+    } catch (e) {
+      logger.error("Failed to open " + FILE_DATABASE + ". Data import will not happen.", e);
+      this.logSQLError(this.connection.lastError, this.connection.lastErrorString);
+      this.connection.rollbackTransaction();
+      return false;
+    }
+
+    return true;
+  },
+
+  _closeConnection: function() {
+    for (let key in this.asyncStatementsCache) {
+      let stmt = this.asyncStatementsCache[key];
+      stmt.finalize();
+    }
+    this.asyncStatementsCache = {};
+
+    if (this.connection)
+      this.connection.asyncClose();
+
+    delete this.connection;
+  },
+
+  /**
+   * Asynchronously retrieve all add-ons from the database, and pass it
+   * to the specified callback
+   *
+   * @param  aCallback
+   *         The callback to pass the add-ons back to
+   */
+  _retrieveStoredData: function(aCallback) {
+    let addons = {};
+
+    // Retrieve all data from the addon table
+    let getAllAddons = () => {
+      this.getAsyncStatement("getAllAddons").executeAsync({
+        handleResult: aResults => {
+          let row = null;
+          while ((row = aResults.getNextRow())) {
+            let internal_id = row.getResultByName("internal_id");
+            addons[internal_id] = this._makeAddonFromAsyncRow(row);
+          }
+        },
+
+        handleError: this.asyncErrorLogger,
+
+        handleCompletion: function(aReason) {
+          if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+            logger.error("Error retrieving add-ons from database. Returning empty results");
+            aCallback({});
+            return;
+          }
+
+          getAllDevelopers();
+        }
+      });
+    }
+
+    // Retrieve all data from the developer table
+    let getAllDevelopers = () => {
+      this.getAsyncStatement("getAllDevelopers").executeAsync({
+        handleResult: aResults => {
+          let row = null;
+          while ((row = aResults.getNextRow())) {
+            let addon_internal_id = row.getResultByName("addon_internal_id");
+            if (!(addon_internal_id in addons)) {
+              logger.warn("Found a developer not linked to an add-on in database");
+              continue;
+            }
+
+            let addon = addons[addon_internal_id];
+            if (!addon.developers)
+              addon.developers = [];
+
+            addon.developers.push(this._makeDeveloperFromAsyncRow(row));
+          }
+        },
+
+        handleError: this.asyncErrorLogger,
+
+        handleCompletion: function(aReason) {
+          if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+            logger.error("Error retrieving developers from database. Returning empty results");
+            aCallback({});
+            return;
+          }
+
+          getAllScreenshots();
+        }
+      });
+    }
+
+    // Retrieve all data from the screenshot table
+    let getAllScreenshots = () => {
+      this.getAsyncStatement("getAllScreenshots").executeAsync({
+        handleResult: aResults => {
+          let row = null;
+          while ((row = aResults.getNextRow())) {
+            let addon_internal_id = row.getResultByName("addon_internal_id");
+            if (!(addon_internal_id in addons)) {
+              logger.warn("Found a screenshot not linked to an add-on in database");
+              continue;
+            }
+
+            let addon = addons[addon_internal_id];
+            if (!addon.screenshots)
+              addon.screenshots = [];
+            addon.screenshots.push(this._makeScreenshotFromAsyncRow(row));
+          }
+        },
+
+        handleError: this.asyncErrorLogger,
+
+        handleCompletion: function(aReason) {
+          if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+            logger.error("Error retrieving screenshots from database. Returning empty results");
+            aCallback({});
+            return;
+          }
+
+          getAllCompatOverrides();
+        }
+      });
+    }
+
+    let getAllCompatOverrides = () => {
+      this.getAsyncStatement("getAllCompatOverrides").executeAsync({
+        handleResult: aResults => {
+          let row = null;
+          while ((row = aResults.getNextRow())) {
+            let addon_internal_id = row.getResultByName("addon_internal_id");
+            if (!(addon_internal_id in addons)) {
+              logger.warn("Found a compatibility override not linked to an add-on in database");
+              continue;
+            }
+
+            let addon = addons[addon_internal_id];
+            if (!addon.compatibilityOverrides)
+              addon.compatibilityOverrides = [];
+            addon.compatibilityOverrides.push(this._makeCompatOverrideFromAsyncRow(row));
+          }
+        },
+
+        handleError: this.asyncErrorLogger,
+
+        handleCompletion: function(aReason) {
+          if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+            logger.error("Error retrieving compatibility overrides from database. Returning empty results");
+            aCallback({});
+            return;
+          }
+
+          getAllIcons();
+        }
+      });
+    }
+
+    let getAllIcons = () => {
+      this.getAsyncStatement("getAllIcons").executeAsync({
+        handleResult: aResults => {
+          let row = null;
+          while ((row = aResults.getNextRow())) {
+            let addon_internal_id = row.getResultByName("addon_internal_id");
+            if (!(addon_internal_id in addons)) {
+              logger.warn("Found an icon not linked to an add-on in database");
+              continue;
+            }
+
+            let addon = addons[addon_internal_id];
+            let { size, url } = this._makeIconFromAsyncRow(row);
+            addon.icons[size] = url;
+            if (size == 32)
+              addon.iconURL = url;
+          }
+        },
+
+        handleError: this.asyncErrorLogger,
+
+        handleCompletion: function(aReason) {
+          if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) {
+            logger.error("Error retrieving icons from database. Returning empty results");
+            aCallback({});
+            return;
+          }
+
+          let returnedAddons = {};
+          for (let id in addons) {
+            let addon = addons[id];
+            returnedAddons[addon.id] = addon;
+          }
+          aCallback(returnedAddons);
+        }
+      });
+    }
+
+    // Begin asynchronous process
+    getAllAddons();
+  },
+
+  // A cache of statements that are used and need to be finalized on shutdown
+  asyncStatementsCache: {},
+
+  /**
+   * Gets a cached async statement or creates a new statement if it doesn't
+   * already exist.
+   *
+   * @param  aKey
+   *         A unique key to reference the statement
+   * @return a mozIStorageAsyncStatement for the SQL corresponding to the
+   *         unique key
+   */
+  getAsyncStatement: function(aKey) {
+    if (aKey in this.asyncStatementsCache)
+      return this.asyncStatementsCache[aKey];
+
+    let sql = this.queries[aKey];
+    try {
+      return this.asyncStatementsCache[aKey] = this.connection.createAsyncStatement(sql);
+    } catch (e) {
+      logger.error("Error creating statement " + aKey + " (" + sql + ")");
+      throw Components.Exception("Error creating statement " + aKey + " (" + sql + "): " + e,
+                                 e.result);
+    }
+  },
+
+  // The queries used by the database
+  queries: {
+    getAllAddons: "SELECT internal_id, id, type, name, version, " +
+                  "creator, creatorURL, description, fullDescription, " +
+                  "developerComments, eula, homepageURL, supportURL, " +
+                  "contributionURL, contributionAmount, averageRating, " +
+                  "reviewCount, reviewURL, totalDownloads, weeklyDownloads, " +
+                  "dailyUsers, sourceURI, repositoryStatus, size, updateDate " +
+                  "FROM addon",
+
+    getAllDevelopers: "SELECT addon_internal_id, name, url FROM developer " +
+                      "ORDER BY addon_internal_id, num",
+
+    getAllScreenshots: "SELECT addon_internal_id, url, width, height, " +
+                       "thumbnailURL, thumbnailWidth, thumbnailHeight, caption " +
+                       "FROM screenshot ORDER BY addon_internal_id, num",
+
+    getAllCompatOverrides: "SELECT addon_internal_id, type, minVersion, " +
+                           "maxVersion, appID, appMinVersion, appMaxVersion " +
+                           "FROM compatibility_override " +
+                           "ORDER BY addon_internal_id, num",
+
+    getAllIcons: "SELECT addon_internal_id, size, url FROM icon " +
+                 "ORDER BY addon_internal_id, size",
+  },
+
+  /**
+   * Make add-on structure from an asynchronous row.
+   *
+   * @param  aRow
+   *         The asynchronous row to use
+   * @return The created add-on
+   */
+  _makeAddonFromAsyncRow: function(aRow) {
+    // This is intentionally not an AddonSearchResult object in order
+    // to allow AddonDatabase._parseAddon to parse it, same as if it
+    // was read from the JSON database.
+
+    let addon = { icons: {} };
+
+    for (let prop of PROP_SINGLE) {
+      addon[prop] = aRow.getResultByName(prop)
+    }
+
+    return addon;
+  },
+
+  /**
+   * Make a developer from an asynchronous row
+   *
+   * @param  aRow
+   *         The asynchronous row to use
+   * @return The created developer
+   */
+  _makeDeveloperFromAsyncRow: function(aRow) {
+    let name = aRow.getResultByName("name");
+    let url = aRow.getResultByName("url")
+    return new AddonManagerPrivate.AddonAuthor(name, url);
+  },
+
+  /**
+   * Make a screenshot from an asynchronous row
+   *
+   * @param  aRow
+   *         The asynchronous row to use
+   * @return The created screenshot
+   */
+  _makeScreenshotFromAsyncRow: function(aRow) {
+    let url = aRow.getResultByName("url");
+    let width = aRow.getResultByName("width");
+    let height = aRow.getResultByName("height");
+    let thumbnailURL = aRow.getResultByName("thumbnailURL");
+    let thumbnailWidth = aRow.getResultByName("thumbnailWidth");
+    let thumbnailHeight = aRow.getResultByName("thumbnailHeight");
+    let caption = aRow.getResultByName("caption");
+    return new AddonManagerPrivate.AddonScreenshot(url, width, height, thumbnailURL,
+                                                   thumbnailWidth, thumbnailHeight, caption);
+  },
+
+  /**
+   * Make a CompatibilityOverride from an asynchronous row
+   *
+   * @param  aRow
+   *         The asynchronous row to use
+   * @return The created CompatibilityOverride
+   */
+  _makeCompatOverrideFromAsyncRow: function(aRow) {
+    let type = aRow.getResultByName("type");
+    let minVersion = aRow.getResultByName("minVersion");
+    let maxVersion = aRow.getResultByName("maxVersion");
+    let appID = aRow.getResultByName("appID");
+    let appMinVersion = aRow.getResultByName("appMinVersion");
+    let appMaxVersion = aRow.getResultByName("appMaxVersion");
+    return new AddonManagerPrivate.AddonCompatibilityOverride(type,
+                                                              minVersion,
+                                                              maxVersion,
+                                                              appID,
+                                                              appMinVersion,
+                                                              appMaxVersion);
+  },
+
+  /**
+   * Make an icon from an asynchronous row
+   *
+   * @param  aRow
+   *         The asynchronous row to use
+   * @return An object containing the size and URL of the icon
+   */
+  _makeIconFromAsyncRow: function(aRow) {
+    let size = aRow.getResultByName("size");
+    let url = aRow.getResultByName("url");
+    return { size: size, url: url };
+  },
+
+  /**
+   * A helper function to log an SQL error.
+   *
+   * @param  aError
+   *         The storage error code associated with the error
+   * @param  aErrorString
+   *         An error message
+   */
+  logSQLError: function(aError, aErrorString) {
+    logger.error("SQL error " + aError + ": " + aErrorString);
+  },
+
+  /**
+   * A helper function to log any errors that occur during async statements.
+   *
+   * @param  aError
+   *         A mozIStorageError to log
+   */
+  asyncErrorLogger: function(aError) {
+    logger.error("Async SQL error " + aError.result + ": " + aError.message);
+  },
+
+  /**
+   * Synchronously creates the triggers in the database.
+   */
+  _createTriggers: function() {
+    this.connection.executeSimpleSQL("DROP TRIGGER IF EXISTS delete_addon");
+    this.connection.executeSimpleSQL("CREATE TRIGGER delete_addon AFTER DELETE " +
+      "ON addon BEGIN " +
+      "DELETE FROM developer WHERE addon_internal_id=old.internal_id; " +
+      "DELETE FROM screenshot WHERE addon_internal_id=old.internal_id; " +
+      "DELETE FROM compatibility_override WHERE addon_internal_id=old.internal_id; " +
+      "DELETE FROM icon WHERE addon_internal_id=old.internal_id; " +
+      "END");
+  },
+
+  /**
+   * Synchronously creates the indices in the database.
+   */
+  _createIndices: function() {
+    this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS developer_idx " +
+                                     "ON developer (addon_internal_id)");
+    this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS screenshot_idx " +
+                                     "ON screenshot (addon_internal_id)");
+    this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS compatibility_override_idx " +
+                                     "ON compatibility_override (addon_internal_id)");
+    this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS icon_idx " +
+                                     "ON icon (addon_internal_id)");
+  }
+}
diff --git a/toolkit/mozapps/webextensions/internal/AddonTestUtils.jsm b/toolkit/mozapps/webextensions/internal/AddonTestUtils.jsm
new file mode 100644
index 000000000..6422929b1
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonTestUtils.jsm
@@ -0,0 +1,1231 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+/* eslint "mozilla/no-aArgs": 1 */
+/* eslint "no-unused-vars": [2, {"args": "none", "varsIgnorePattern": "^(Cc|Ci|Cr|Cu|EXPORTED_SYMBOLS)$"}] */
+/* eslint "semi": [2, "always"] */
+/* eslint "valid-jsdoc": [2, {requireReturn: false}] */
+
+var EXPORTED_SYMBOLS = ["AddonTestUtils", "MockAsyncShutdown"];
+
+const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+const CERTDB_CONTRACTID = "@mozilla.org/security/x509certdb;1";
+const CERTDB_CID = Components.ID("{fb0bbc5c-452e-4783-b32c-80124693d871}");
+
+
+Cu.importGlobalProperties(["fetch", "TextEncoder"]);
+
+Cu.import("resource://gre/modules/AsyncShutdown.jsm");
+Cu.import("resource://gre/modules/FileUtils.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {});
+const {OS} = Cu.import("resource://gre/modules/osfile.jsm", {});
+
+XPCOMUtils.defineLazyModuleGetter(this, "Extension",
+                                  "resource://gre/modules/Extension.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "rdfService",
+                                   "@mozilla.org/rdf/rdf-service;1", "nsIRDFService");
+XPCOMUtils.defineLazyServiceGetter(this, "uuidGen",
+                                   "@mozilla.org/uuid-generator;1", "nsIUUIDGenerator");
+
+
+XPCOMUtils.defineLazyGetter(this, "AppInfo", () => {
+  let AppInfo = {};
+  Cu.import("resource://testing-common/AppInfo.jsm", AppInfo);
+  return AppInfo;
+});
+
+
+const ArrayBufferInputStream = Components.Constructor(
+  "@mozilla.org/io/arraybuffer-input-stream;1",
+  "nsIArrayBufferInputStream", "setData");
+
+const nsFile = Components.Constructor(
+  "@mozilla.org/file/local;1",
+  "nsIFile", "initWithPath");
+
+const RDFXMLParser = Components.Constructor(
+  "@mozilla.org/rdf/xml-parser;1",
+  "nsIRDFXMLParser", "parseString");
+
+const RDFDataSource = Components.Constructor(
+  "@mozilla.org/rdf/datasource;1?name=in-memory-datasource",
+  "nsIRDFDataSource");
+
+const ZipReader = Components.Constructor(
+  "@mozilla.org/libjar/zip-reader;1",
+  "nsIZipReader", "open");
+
+const ZipWriter = Components.Constructor(
+  "@mozilla.org/zipwriter;1",
+  "nsIZipWriter", "open");
+
+
+// We need some internal bits of AddonManager
+var AMscope = Cu.import("resource://gre/modules/AddonManager.jsm", {});
+var {AddonManager, AddonManagerPrivate} = AMscope;
+
+
+// Mock out AddonManager's reference to the AsyncShutdown module so we can shut
+// down AddonManager from the test
+var MockAsyncShutdown = {
+  hook: null,
+  status: null,
+  profileBeforeChange: {
+    addBlocker: function(name, blocker, options) {
+      MockAsyncShutdown.hook = blocker;
+      MockAsyncShutdown.status = options.fetchState;
+    }
+  },
+  // We can use the real Barrier
+  Barrier: AsyncShutdown.Barrier,
+};
+
+AMscope.AsyncShutdown = MockAsyncShutdown;
+
+
+/**
+ * Escapes any occurances of &, ", < or > with XML entities.
+ *
+ * @param {string} str
+ *        The string to escape.
+ * @return {string} The escaped string.
+ */
+function escapeXML(str) {
+  let replacements = {"&": "&amp;", '"': "&quot;", "'": "&apos;", "<": "&lt;", ">": "&gt;"};
+  return String(str).replace(/[&"''<>]/g, m => replacements[m]);
+}
+
+/**
+ * A tagged template function which escapes any XML metacharacters in
+ * interpolated values.
+ *
+ * @param {Array<string>} strings
+ *        An array of literal strings extracted from the templates.
+ * @param {Array} values
+ *        An array of interpolated values extracted from the template.
+ * @returns {string}
+ *        The result of the escaped values interpolated with the literal
+ *        strings.
+ */
+function escaped(strings, ...values) {
+  let result = [];
+
+  for (let [i, string] of strings.entries()) {
+    result.push(string);
+    if (i < values.length)
+      result.push(escapeXML(values[i]));
+  }
+
+  return result.join("");
+}
+
+
+class AddonsList {
+  constructor(extensionsINI) {
+    this.multiprocessIncompatibleIDs = new Set();
+
+    if (!extensionsINI.exists()) {
+      this.extensions = [];
+      this.themes = [];
+      return;
+    }
+
+    let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"]
+                  .getService(Ci.nsIINIParserFactory);
+
+    let parser = factory.createINIParser(extensionsINI);
+
+    function readDirectories(section) {
+      var dirs = [];
+      var keys = parser.getKeys(section);
+      for (let key of XPCOMUtils.IterStringEnumerator(keys)) {
+        let descriptor = parser.getString(section, key);
+
+        let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+        try {
+          file.persistentDescriptor = descriptor;
+        } catch (e) {
+          // Throws if the directory doesn't exist, we can ignore this since the
+          // platform will too.
+          continue;
+        }
+        dirs.push(file);
+      }
+      return dirs;
+    }
+
+    this.extensions = readDirectories("ExtensionDirs");
+    this.themes = readDirectories("ThemeDirs");
+
+    var keys = parser.getKeys("MultiprocessIncompatibleExtensions");
+    for (let key of XPCOMUtils.IterStringEnumerator(keys)) {
+      let id = parser.getString("MultiprocessIncompatibleExtensions", key);
+      this.multiprocessIncompatibleIDs.add(id);
+    }
+  }
+
+  hasItem(type, dir, id) {
+    var path = dir.clone();
+    path.append(id);
+
+    var xpiPath = dir.clone();
+    xpiPath.append(`${id}.xpi`);
+
+    return this[type].some(file => {
+      if (!file.exists())
+        throw new Error(`Non-existent path found in extensions.ini: ${file.path}`);
+
+      if (file.isDirectory())
+        return file.equals(path);
+      if (file.isFile())
+        return file.equals(xpiPath);
+      return false;
+    });
+  }
+
+  isMultiprocessIncompatible(id) {
+    return this.multiprocessIncompatibleIDs.has(id);
+  }
+
+  hasTheme(dir, id) {
+    return this.hasItem("themes", dir, id);
+  }
+
+  hasExtension(dir, id) {
+    return this.hasItem("extensions", dir, id);
+  }
+}
+
+var AddonTestUtils = {
+  addonIntegrationService: null,
+  addonsList: null,
+  appInfo: null,
+  extensionsINI: null,
+  testUnpacked: false,
+  useRealCertChecks: false,
+
+  init(testScope) {
+    this.testScope = testScope;
+
+    // Get the profile directory for tests to use.
+    this.profileDir = testScope.do_get_profile();
+
+    this.extensionsINI = this.profileDir.clone();
+    this.extensionsINI.append("extensions.ini");
+
+    // Register a temporary directory for the tests.
+    this.tempDir = this.profileDir.clone();
+    this.tempDir.append("temp");
+    this.tempDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+    this.registerDirectory("TmpD", this.tempDir);
+
+    // Create a replacement app directory for the tests.
+    const appDirForAddons = this.profileDir.clone();
+    appDirForAddons.append("appdir-addons");
+    appDirForAddons.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+    this.registerDirectory("XREAddonAppDir", appDirForAddons);
+
+
+    // Enable more extensive EM logging
+    Services.prefs.setBoolPref("extensions.logging.enabled", true);
+
+    // By default only load extensions from the profile install location
+    Services.prefs.setIntPref("extensions.enabledScopes", AddonManager.SCOPE_PROFILE);
+
+    // By default don't disable add-ons from any scope
+    Services.prefs.setIntPref("extensions.autoDisableScopes", 0);
+
+    // By default, don't cache add-ons in AddonRepository.jsm
+    Services.prefs.setBoolPref("extensions.getAddons.cache.enabled", false);
+
+    // Disable the compatibility updates window by default
+    Services.prefs.setBoolPref("extensions.showMismatchUI", false);
+
+    // Point update checks to the local machine for fast failures
+    Services.prefs.setCharPref("extensions.update.url", "http://127.0.0.1/updateURL");
+    Services.prefs.setCharPref("extensions.update.background.url", "http://127.0.0.1/updateBackgroundURL");
+    Services.prefs.setCharPref("extensions.blocklist.url", "http://127.0.0.1/blocklistURL");
+
+    // By default ignore bundled add-ons
+    Services.prefs.setBoolPref("extensions.installDistroAddons", false);
+
+    // By default don't check for hotfixes
+    Services.prefs.setCharPref("extensions.hotfix.id", "");
+
+    // Ensure signature checks are enabled by default
+    Services.prefs.setBoolPref("xpinstall.signatures.required", true);
+
+
+    // Write out an empty blocklist.xml file to the profile to ensure nothing
+    // is blocklisted by default
+    var blockFile = OS.Path.join(this.profileDir.path, "blocklist.xml");
+
+    var data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+               "<blocklist xmlns=\"http://www.mozilla.org/2006/addons-blocklist\">\n" +
+               "</blocklist>\n";
+
+    this.awaitPromise(OS.File.writeAtomic(blockFile, new TextEncoder().encode(data)));
+
+
+    // Make sure that a given path does not exist
+    function pathShouldntExist(file) {
+      if (file.exists()) {
+        throw new Error(`Test cleanup: path ${file.path} exists when it should not`);
+      }
+    }
+
+    testScope.do_register_cleanup(() => {
+      for (let file of this.tempXPIs) {
+        if (file.exists())
+          file.remove(false);
+      }
+
+      // Check that the temporary directory is empty
+      var dirEntries = this.tempDir.directoryEntries
+                           .QueryInterface(Ci.nsIDirectoryEnumerator);
+      var entries = [];
+      while (dirEntries.hasMoreElements())
+        entries.push(dirEntries.nextFile.leafName);
+      if (entries.length)
+        throw new Error(`Found unexpected files in temporary directory: ${entries.join(", ")}`);
+
+      dirEntries.close();
+
+      try {
+        appDirForAddons.remove(true);
+      } catch (ex) {
+        testScope.do_print(`Got exception removing addon app dir: ${ex}`);
+      }
+
+      // ensure no leftover files in the system addon upgrade location
+      let featuresDir = this.profileDir.clone();
+      featuresDir.append("features");
+      // upgrade directories will be in UUID folders under features/
+      let systemAddonDirs = [];
+      if (featuresDir.exists()) {
+        let featuresDirEntries = featuresDir.directoryEntries
+                                            .QueryInterface(Ci.nsIDirectoryEnumerator);
+        while (featuresDirEntries.hasMoreElements()) {
+          let entry = featuresDirEntries.getNext();
+          entry.QueryInterface(Components.interfaces.nsIFile);
+          systemAddonDirs.push(entry);
+        }
+
+        systemAddonDirs.map(dir => {
+          dir.append("stage");
+          pathShouldntExist(dir);
+        });
+      }
+
+      // ensure no leftover files in the user addon location
+      let testDir = this.profileDir.clone();
+      testDir.append("extensions");
+      testDir.append("trash");
+      pathShouldntExist(testDir);
+
+      testDir.leafName = "staged";
+      pathShouldntExist(testDir);
+
+      return this.promiseShutdownManager();
+    });
+  },
+
+  /**
+   * Helper to spin the event loop until a promise resolves or rejects
+   *
+   * @param {Promise} promise
+   *        The promise to wait on.
+   * @returns {*} The promise's resolution value.
+   * @throws The promise's rejection value, if it rejects.
+   */
+  awaitPromise(promise) {
+    let done = false;
+    let result;
+    let error;
+    promise.then(
+      val => { result = val; },
+      err => { error = err; }
+    ).then(() => {
+      done = true;
+    });
+
+    while (!done)
+      Services.tm.mainThread.processNextEvent(true);
+
+    if (error !== undefined)
+      throw error;
+    return result;
+  },
+
+  createAppInfo(ID, name, version, platformVersion = "1.0") {
+    AppInfo.updateAppInfo({
+      ID, name, version, platformVersion,
+      crashReporter: true,
+      extraProps: {
+        browserTabsRemoteAutostart: false,
+      },
+    });
+    this.appInfo = AppInfo.getAppInfo();
+  },
+
+  getManifestURI(file) {
+    if (file.isDirectory()) {
+      file.append("install.rdf");
+      if (file.exists()) {
+        return NetUtil.newURI(file);
+      }
+
+      file.leafName = "manifest.json";
+      if (file.exists())
+        return NetUtil.newURI(file);
+
+      throw new Error("No manifest file present");
+    }
+
+    let zip = ZipReader(file);
+    try {
+      let uri = NetUtil.newURI(file);
+
+      if (zip.hasEntry("install.rdf")) {
+        return NetUtil.newURI(`jar:${uri.spec}!/install.rdf`);
+      }
+
+      if (zip.hasEntry("manifest.json")) {
+        return NetUtil.newURI(`jar:${uri.spec}!/manifest.json`);
+      }
+
+      throw new Error("No manifest file present");
+    } finally {
+      zip.close();
+    }
+  },
+
+  getIDFromManifest: Task.async(function*(manifestURI) {
+    let body = yield fetch(manifestURI.spec);
+
+    if (manifestURI.spec.endsWith(".rdf")) {
+      let data = yield body.text();
+
+      let ds = new RDFDataSource();
+      new RDFXMLParser(ds, manifestURI, data);
+
+      let rdfID = ds.GetTarget(rdfService.GetResource("urn:mozilla:install-manifest"),
+                               rdfService.GetResource("http://www.mozilla.org/2004/em-rdf#id"),
+                               true);
+      return rdfID.QueryInterface(Ci.nsIRDFLiteral).Value;
+    }
+
+    let manifest = yield body.json();
+    try {
+      return manifest.applications.gecko.id;
+    } catch (e) {
+      // IDs for WebExtensions are extracted from the certificate when
+      // not present in the manifest, so just generate a random one.
+      return uuidGen.generateUUID().number;
+    }
+  }),
+
+  overrideCertDB() {
+    // Unregister the real database. This only works because the add-ons manager
+    // hasn't started up and grabbed the certificate database yet.
+    let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+    let factory = registrar.getClassObject(CERTDB_CID, Ci.nsIFactory);
+    registrar.unregisterFactory(CERTDB_CID, factory);
+
+    // Get the real DB
+    let realCertDB = factory.createInstance(null, Ci.nsIX509CertDB);
+
+
+    let verifyCert = Task.async(function*(file, result, cert, callback) {
+      if (result == Cr.NS_ERROR_SIGNED_JAR_NOT_SIGNED &&
+          !this.useRealCertChecks && callback.wrappedJSObject) {
+        // Bypassing XPConnect allows us to create a fake x509 certificate from JS
+        callback = callback.wrappedJSObject;
+
+        try {
+          let manifestURI = this.getManifestURI(file);
+
+          let id = yield this.getIDFromManifest(manifestURI);
+
+          let fakeCert = {commonName: id};
+
+          return [callback, Cr.NS_OK, fakeCert];
+        } catch (e) {
+          // If there is any error then just pass along the original results
+        } finally {
+          // Make sure to close the open zip file or it will be locked.
+          if (file.isFile())
+            Services.obs.notifyObservers(file, "flush-cache-entry", "cert-override");
+        }
+      }
+
+      return [callback, result, cert];
+    }).bind(this);
+
+
+    function FakeCertDB() {
+      for (let property of Object.keys(realCertDB)) {
+        if (property in this)
+          continue;
+
+        if (typeof realCertDB[property] == "function")
+          this[property] = realCertDB[property].bind(realCertDB);
+      }
+    }
+    FakeCertDB.prototype = {
+      openSignedAppFileAsync(root, file, callback) {
+        // First try calling the real cert DB
+        realCertDB.openSignedAppFileAsync(root, file, (result, zipReader, cert) => {
+          verifyCert(file.clone(), result, cert, callback)
+            .then(([callback, result, cert]) => {
+              callback.openSignedAppFileFinished(result, zipReader, cert);
+            });
+        });
+      },
+
+      verifySignedDirectoryAsync(root, dir, callback) {
+        // First try calling the real cert DB
+        realCertDB.verifySignedDirectoryAsync(root, dir, (result, cert) => {
+          verifyCert(dir.clone(), result, cert, callback)
+            .then(([callback, result, cert]) => {
+              callback.verifySignedDirectoryFinished(result, cert);
+            });
+        });
+      },
+
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsIX509CertDB]),
+    };
+
+    let certDBFactory = XPCOMUtils.generateSingletonFactory(FakeCertDB);
+    registrar.registerFactory(CERTDB_CID, "CertDB",
+                              CERTDB_CONTRACTID, certDBFactory);
+  },
+
+  /**
+   * Starts up the add-on manager as if it was started by the application.
+   *
+   * @param {boolean} [appChanged = true]
+   *        An optional boolean parameter to simulate the case where the
+   *        application has changed version since the last run. If not passed it
+   *        defaults to true
+   * @returns {Promise}
+   *        Resolves when the add-on manager's startup has completed.
+   */
+  promiseStartupManager(appChanged = true) {
+    if (this.addonIntegrationService)
+      throw new Error("Attempting to startup manager that was already started.");
+
+    if (appChanged && this.extensionsINI.exists())
+      this.extensionsINI.remove(true);
+
+    this.addonIntegrationService = Cc["@mozilla.org/addons/integration;1"]
+          .getService(Ci.nsIObserver);
+
+    this.addonIntegrationService.observe(null, "addons-startup", null);
+
+    this.emit("addon-manager-started");
+
+    // Load the add-ons list as it was after extension registration
+    this.loadAddonsList();
+
+    return Promise.resolve();
+  },
+
+  promiseShutdownManager() {
+    if (!this.addonIntegrationService)
+      return Promise.resolve(false);
+
+    Services.obs.notifyObservers(null, "quit-application-granted", null);
+    return MockAsyncShutdown.hook()
+      .then(() => {
+        this.emit("addon-manager-shutdown");
+
+        this.addonIntegrationService = null;
+
+        // Load the add-ons list as it was after application shutdown
+        this.loadAddonsList();
+
+        // Clear any crash report annotations
+        this.appInfo.annotations = {};
+
+        // Force the XPIProvider provider to reload to better
+        // simulate real-world usage.
+        let XPIscope = Cu.import("resource://gre/modules/addons/XPIProvider.jsm");
+        // This would be cleaner if I could get it as the rejection reason from
+        // the AddonManagerInternal.shutdown() promise
+        let shutdownError = XPIscope.XPIProvider._shutdownError;
+
+        AddonManagerPrivate.unregisterProvider(XPIscope.XPIProvider);
+        Cu.unload("resource://gre/modules/addons/XPIProvider.jsm");
+
+        if (shutdownError)
+          throw shutdownError;
+
+        return true;
+      });
+  },
+
+  promiseRestartManager(newVersion) {
+    return this.promiseShutdownManager()
+      .then(() => {
+        if (newVersion)
+          this.appInfo.version = newVersion;
+
+        return this.promiseStartupManager(!!newVersion);
+      });
+  },
+
+  loadAddonsList() {
+    this.addonsList = new AddonsList(this.extensionsINI);
+  },
+
+  /**
+   * Creates an update.rdf structure as a string using for the update data passed.
+   *
+   * @param {Object} data
+   *        The update data as a JS object. Each property name is an add-on ID,
+   *        the property value is an array of each version of the add-on. Each
+   *        array value is a JS object containing the data for the version, at
+   *        minimum a "version" and "targetApplications" property should be
+   *        included to create a functional update manifest.
+   * @return {string} The update.rdf structure as a string.
+   */
+  createUpdateRDF(data) {
+    var rdf = '<?xml version="1.0"?>\n';
+    rdf += '<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"\n' +
+           '     xmlns:em="http://www.mozilla.org/2004/em-rdf#">\n';
+
+    for (let addon in data) {
+      rdf += escaped`  <Description about="urn:mozilla:extension:${addon}"><em:updates><Seq>\n`;
+
+      for (let versionData of data[addon]) {
+        rdf += '    <li><Description>\n';
+        rdf += this._writeProps(versionData, ["version", "multiprocessCompatible"],
+                                `      `);
+        for (let app of versionData.targetApplications || []) {
+          rdf += "      <em:targetApplication><Description>\n";
+          rdf += this._writeProps(app, ["id", "minVersion", "maxVersion", "updateLink", "updateHash"],
+                                  `        `);
+          rdf += "      </Description></em:targetApplication>\n";
+        }
+        rdf += '    </Description></li>\n';
+      }
+      rdf += '  </Seq></em:updates></Description>\n';
+    }
+    rdf += "</RDF>\n";
+
+    return rdf;
+  },
+
+  _writeProps(obj, props, indent = "  ") {
+    let items = [];
+    for (let prop of props) {
+      if (prop in obj)
+        items.push(escaped`${indent}<em:${prop}>${obj[prop]}</em:${prop}>\n`);
+    }
+    return items.join("");
+  },
+
+  _writeArrayProps(obj, props, indent = "  ") {
+    let items = [];
+    for (let prop of props) {
+      for (let val of obj[prop] || [])
+        items.push(escaped`${indent}<em:${prop}>${val}</em:${prop}>\n`);
+    }
+    return items.join("");
+  },
+
+  _writeLocaleStrings(data) {
+    let items = [];
+
+    items.push(this._writeProps(data, ["name", "description", "creator", "homepageURL"]));
+    items.push(this._writeArrayProps(data, ["developer", "translator", "contributor"]));
+
+    return items.join("");
+  },
+
+  createInstallRDF(data) {
+    var rdf = '<?xml version="1.0"?>\n';
+    rdf += '<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"\n' +
+           '     xmlns:em="http://www.mozilla.org/2004/em-rdf#">\n';
+
+    rdf += '<Description about="urn:mozilla:install-manifest">\n';
+
+    let props = ["id", "version", "type", "internalName", "updateURL", "updateKey",
+                 "optionsURL", "optionsType", "aboutURL", "iconURL", "icon64URL",
+                 "skinnable", "bootstrap", "unpack", "strictCompatibility",
+                 "multiprocessCompatible", "hasEmbeddedWebExtension"];
+    rdf += this._writeProps(data, props);
+
+    rdf += this._writeLocaleStrings(data);
+
+    for (let platform of data.targetPlatforms || [])
+      rdf += escaped`<em:targetPlatform>${platform}</em:targetPlatform>\n`;
+
+    for (let app of data.targetApplications || []) {
+      rdf += "<em:targetApplication><Description>\n";
+      rdf += this._writeProps(app, ["id", "minVersion", "maxVersion"]);
+      rdf += "</Description></em:targetApplication>\n";
+    }
+
+    for (let localized of data.localized || []) {
+      rdf += "<em:localized><Description>\n";
+      rdf += this._writeArrayProps(localized, ["locale"]);
+      rdf += this._writeLocaleStrings(localized);
+      rdf += "</Description></em:localized>\n";
+    }
+
+    for (let dep of data.dependencies || [])
+      rdf += escaped`<em:dependency><Description em:id="${dep}"/></em:dependency>\n`;
+
+    rdf += "</Description>\n</RDF>\n";
+    return rdf;
+  },
+
+  /**
+   * Recursively create all directories upto and including the given
+   * path, if they do not exist.
+   *
+   * @param {string} path The path of the directory to create.
+   * @returns {Promise} Resolves when all directories have been created.
+   */
+  recursiveMakeDir(path) {
+    let paths = [];
+    for (let lastPath; path != lastPath; lastPath = path, path = OS.Path.dirname(path))
+      paths.push(path);
+
+    return Promise.all(paths.reverse().map(path =>
+      OS.File.makeDir(path, {ignoreExisting: true}).catch(() => {})));
+  },
+
+  /**
+   * Writes the given data to a file in the given zip file.
+   *
+   * @param {string|nsIFile} zipFile
+   *        The zip file to write to.
+   * @param {Object} files
+   *        An object containing filenames and the data to write to the
+   *        corresponding paths in the zip file.
+   * @param {integer} [flags = 0]
+   *        Additional flags to open the file with.
+   */
+  writeFilesToZip(zipFile, files, flags = 0) {
+    if (typeof zipFile == "string")
+      zipFile = nsFile(zipFile);
+
+    var zipW = ZipWriter(zipFile, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE | flags);
+
+    for (let [path, data] of Object.entries(files)) {
+      if (!(data instanceof ArrayBuffer))
+        data = new TextEncoder("utf-8").encode(data).buffer;
+
+      let stream = ArrayBufferInputStream(data, 0, data.byteLength);
+
+      // Note these files are being created in the XPI archive with date "0" which is 1970-01-01.
+      zipW.addEntryStream(path, 0, Ci.nsIZipWriter.COMPRESSION_NONE,
+                          stream, false);
+    }
+
+    zipW.close();
+  },
+
+  promiseWriteFilesToZip: Task.async(function*(zip, files, flags) {
+    yield this.recursiveMakeDir(OS.Path.dirname(zip));
+
+    this.writeFilesToZip(zip, files, flags);
+
+    return Promise.resolve(nsFile(zip));
+  }),
+
+  promiseWriteFilesToDir: Task.async(function*(dir, files) {
+    yield this.recursiveMakeDir(dir);
+
+    for (let [path, data] of Object.entries(files)) {
+      path = path.split("/");
+      let leafName = path.pop();
+
+      // Create parent directories, if necessary.
+      let dirPath = dir;
+      for (let subDir of path) {
+        dirPath = OS.Path.join(dirPath, subDir);
+        yield OS.Path.makeDir(dirPath, {ignoreExisting: true});
+      }
+
+      if (typeof data == "string")
+        data = new TextEncoder("utf-8").encode(data);
+
+      yield OS.File.writeAtomic(OS.Path.join(dirPath, leafName), data);
+    }
+
+    return nsFile(dir);
+  }),
+
+  promiseWriteFilesToExtension(dir, id, files, unpacked = this.testUnpacked) {
+    if (typeof files["install.rdf"] === "object")
+      files["install.rdf"] = this.createInstallRDF(files["install.rdf"]);
+
+    if (unpacked) {
+      let path = OS.Path.join(dir, id);
+
+      return this.promiseWriteFilesToDir(path, files);
+    }
+
+    let xpi = OS.Path.join(dir, `${id}.xpi`);
+
+    return this.promiseWriteFilesToZip(xpi, files);
+  },
+
+  tempXPIs: [],
+  /**
+   * Creates an XPI file for some manifest data in the temporary directory and
+   * returns the nsIFile for it. The file will be deleted when the test completes.
+   *
+   * @param {object} files
+   *          The object holding data about the add-on
+   * @return {nsIFile} A file pointing to the created XPI file
+   */
+  createTempXPIFile(files) {
+    var file = this.tempDir.clone();
+    let uuid = uuidGen.generateUUID().number.slice(1, -1);
+    file.append(`${uuid}.xpi`);
+
+    this.tempXPIs.push(file);
+
+    if (typeof files["install.rdf"] === "object")
+      files["install.rdf"] = this.createInstallRDF(files["install.rdf"]);
+
+    this.writeFilesToZip(file.path, files);
+    return file;
+  },
+
+  /**
+   * Creates an XPI file for some WebExtension data in the temporary directory and
+   * returns the nsIFile for it. The file will be deleted when the test completes.
+   *
+   * @param {Object} data
+   *        The object holding data about the add-on, as expected by
+   *        |Extension.generateXPI|.
+   * @return {nsIFile} A file pointing to the created XPI file
+   */
+  createTempWebExtensionFile(data) {
+    let file = Extension.generateXPI(data);
+    this.tempXPIs.push(file);
+    return file;
+  },
+
+  /**
+   * Creates an extension proxy file.
+   * See: https://developer.mozilla.org/en-US/Add-ons/Setting_up_extension_development_environment#Firefox_extension_proxy_file
+   *
+   * @param {nsIFile} dir
+   *        The directory to add the proxy file to.
+   * @param {nsIFile} addon
+   *        An nsIFile for the add-on file that this is a proxy file for.
+   * @param {string} id
+   *        A string to use for the add-on ID.
+   * @returns {Promise} Resolves when the file has been created.
+   */
+  promiseWriteProxyFileToDir(dir, addon, id) {
+    let files = {
+      [id]: addon.path,
+    };
+
+    return this.promiseWriteFilesToDir(dir.path, files);
+  },
+
+  /**
+   * Manually installs an XPI file into an install location by either copying the
+   * XPI there or extracting it depending on whether unpacking is being tested
+   * or not.
+   *
+   * @param {nsIFile} xpiFile
+   *        The XPI file to install.
+   * @param {nsIFile} installLocation
+   *        The install location (an nsIFile) to install into.
+   * @param {string} id
+   *        The ID to install as.
+   * @param {boolean} [unpacked = this.testUnpacked]
+   *        If true, install as an unpacked directory, rather than a
+   *        packed XPI.
+   * @returns {nsIFile}
+   *        A file pointing to the installed location of the XPI file or
+   *        unpacked directory.
+   */
+  manuallyInstall(xpiFile, installLocation, id, unpacked = this.testUnpacked) {
+    if (unpacked) {
+      let dir = installLocation.clone();
+      dir.append(id);
+      dir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+
+      let zip = ZipReader(xpiFile);
+      let entries = zip.findEntries(null);
+      while (entries.hasMore()) {
+        let entry = entries.getNext();
+        let target = dir.clone();
+        for (let part of entry.split("/"))
+          target.append(part);
+        zip.extract(entry, target);
+      }
+      zip.close();
+
+      return dir;
+    }
+
+    let target = installLocation.clone();
+    target.append(`${id}.xpi`);
+    xpiFile.copyTo(target.parent, target.leafName);
+    return target;
+  },
+
+  /**
+   * Manually uninstalls an add-on by removing its files from the install
+   * location.
+   *
+   * @param {nsIFile} installLocation
+   *        The nsIFile of the install location to remove from.
+   * @param {string} id
+   *        The ID of the add-on to remove.
+   * @param {boolean} [unpacked = this.testUnpacked]
+   *        If true, uninstall an unpacked directory, rather than a
+   *        packed XPI.
+   */
+  manuallyUninstall(installLocation, id, unpacked = this.testUnpacked) {
+    let file = this.getFileForAddon(installLocation, id, unpacked);
+
+    // In reality because the app is restarted a flush isn't necessary for XPIs
+    // removed outside the app, but for testing we must flush manually.
+    if (file.isFile())
+      Services.obs.notifyObservers(file, "flush-cache-entry", null);
+
+    file.remove(true);
+  },
+
+  /**
+   * Gets the nsIFile for where an add-on is installed. It may point to a file or
+   * a directory depending on whether add-ons are being installed unpacked or not.
+   *
+   * @param {nsIFile} dir
+   *         The nsIFile for the install location
+   * @param {string} id
+   *        The ID of the add-on
+   * @param {boolean} [unpacked = this.testUnpacked]
+   *        If true, return the path to an unpacked directory, rather than a
+   *        packed XPI.
+   * @returns {nsIFile}
+   *        A file pointing to the XPI file or unpacked directory where
+   *        the add-on should be installed.
+   */
+  getFileForAddon(dir, id, unpacked = this.testUnpacked) {
+    dir = dir.clone();
+    if (unpacked)
+      dir.append(id);
+    else
+      dir.append(`${id}.xpi`);
+    return dir;
+  },
+
+  /**
+   * Sets the last modified time of the extension, usually to trigger an update
+   * of its metadata. If the extension is unpacked, this function assumes that
+   * the extension contains only the install.rdf file.
+   *
+   * @param {nsIFile} ext A file pointing to either the packed extension or its unpacked directory.
+   * @param {number} time The time to which we set the lastModifiedTime of the extension
+   *
+   * @deprecated Please use promiseSetExtensionModifiedTime instead
+   */
+  setExtensionModifiedTime(ext, time) {
+    ext.lastModifiedTime = time;
+    if (ext.isDirectory()) {
+      let entries = ext.directoryEntries
+                       .QueryInterface(Ci.nsIDirectoryEnumerator);
+      while (entries.hasMoreElements())
+        this.setExtensionModifiedTime(entries.nextFile, time);
+      entries.close();
+    }
+  },
+
+  promiseSetExtensionModifiedTime: Task.async(function*(path, time) {
+    yield OS.File.setDates(path, time, time);
+
+    let iterator = new OS.File.DirectoryIterator(path);
+    try {
+      yield iterator.forEach(entry => {
+        return this.promiseSetExtensionModifiedTime(entry.path, time);
+      });
+    } catch (ex) {
+      if (ex instanceof OS.File.Error)
+        return;
+      throw ex;
+    } finally {
+      iterator.close().catch(() => {});
+    }
+  }),
+
+  registerDirectory(key, dir) {
+    var dirProvider = {
+      getFile(prop, persistent) {
+        persistent.value = false;
+        if (prop == key)
+          return dir.clone();
+        return null;
+      },
+
+      QueryInterface: XPCOMUtils.generateQI([Ci.nsIDirectoryServiceProvider]),
+    };
+    Services.dirsvc.registerProvider(dirProvider);
+  },
+
+  /**
+   * Returns a promise that resolves when the given add-on event is fired. The
+   * resolved value is an array of arguments passed for the event.
+   *
+   * @param {string} event
+   *        The name of the AddonListener event handler method for which
+   *        an event is expected.
+   * @returns {Promise<Array>}
+   *        Resolves to an array containing the event handler's
+   *        arguments the first time it is called.
+   */
+  promiseAddonEvent(event) {
+    return new Promise(resolve => {
+      let listener = {
+        [event](...args) {
+          AddonManager.removeAddonListener(listener);
+          resolve(args);
+        },
+      };
+
+      AddonManager.addAddonListener(listener);
+    });
+  },
+
+  /**
+   * A helper method to install AddonInstall and wait for completion.
+   *
+   * @param {AddonInstall} install
+   *        The add-on to install.
+   * @returns {Promise}
+   *        Resolves when the install completes, either successfully or
+   *        in failure.
+   */
+  promiseCompleteInstall(install) {
+    let listener;
+    return new Promise(resolve => {
+      listener = {
+        onDownloadFailed: resolve,
+        onDownloadCancelled: resolve,
+        onInstallFailed: resolve,
+        onInstallCancelled: resolve,
+        onInstallEnded: resolve,
+        onInstallPostponed: resolve,
+      };
+
+      install.addListener(listener);
+      install.install();
+    }).then(() => {
+      install.removeListener(listener);
+    });
+  },
+
+  /**
+   * A helper method to install a file.
+   *
+   * @param {nsIFile} file
+   *        The file to install
+   * @param {boolean} [ignoreIncompatible = false]
+   *        Optional parameter to ignore add-ons that are incompatible
+   *        with the application
+   * @returns {Promise}
+   *        Resolves when the install has completed.
+   */
+  promiseInstallFile(file, ignoreIncompatible = false) {
+    return new Promise((resolve, reject) => {
+      AddonManager.getInstallForFile(file, install => {
+        if (!install)
+          reject(new Error(`No AddonInstall created for ${file.path}`));
+        else if (install.state != AddonManager.STATE_DOWNLOADED)
+          reject(new Error(`Expected file to be downloaded for install of ${file.path}`));
+        else if (ignoreIncompatible && install.addon.appDisabled)
+          resolve();
+        else
+          resolve(this.promiseCompleteInstall(install));
+      });
+    });
+  },
+
+  /**
+   * A helper method to install an array of files.
+   *
+   * @param {Iterable<nsIFile>} files
+   *        The files to install
+   * @param {boolean} [ignoreIncompatible = false]
+   *        Optional parameter to ignore add-ons that are incompatible
+   *        with the application
+   * @returns {Promise}
+   *        Resolves when the installs have completed.
+   */
+  promiseInstallAllFiles(files, ignoreIncompatible = false) {
+    return Promise.all(Array.from(
+      files,
+      file => this.promiseInstallFile(file, ignoreIncompatible)));
+  },
+
+  promiseCompleteAllInstalls(installs) {
+    return Promise.all(Array.from(installs, this.promiseCompleteInstall));
+  },
+
+  /**
+   * A promise-based variant of AddonManager.getAddonsByIDs.
+   *
+   * @param {Array<string>} list
+   *        As the first argument of AddonManager.getAddonsByIDs
+   * @return {Promise<Array<Addon>>}
+   *        Resolves to the array of add-ons for the given IDs.
+   */
+  promiseAddonsByIDs(list) {
+    return new Promise(resolve => AddonManager.getAddonsByIDs(list, resolve));
+  },
+
+  /**
+   * A promise-based variant of AddonManager.getAddonByID.
+   *
+   * @param {string} id
+   *        The ID of the add-on.
+   * @return {Promise<Addon>}
+   *        Resolves to the add-on with the given ID.
+   */
+  promiseAddonByID(id) {
+    return new Promise(resolve => AddonManager.getAddonByID(id, resolve));
+  },
+
+  /**
+   * Returns a promise that will be resolved when an add-on update check is
+   * complete. The value resolved will be an AddonInstall if a new version was
+   * found.
+   *
+   * @param {object} addon The add-on to find updates for.
+   * @param {integer} reason The type of update to find.
+   * @return {Promise<object>} an object containing information about the update.
+   */
+  promiseFindAddonUpdates(addon, reason = AddonManager.UPDATE_WHEN_PERIODIC_UPDATE) {
+    let equal = this.testScope.equal;
+    return new Promise((resolve, reject) => {
+      let result = {};
+      addon.findUpdates({
+        onNoCompatibilityUpdateAvailable: function(addon2) {
+          if ("compatibilityUpdate" in result) {
+            throw new Error("Saw multiple compatibility update events");
+          }
+          equal(addon, addon2, "onNoCompatibilityUpdateAvailable");
+          result.compatibilityUpdate = false;
+        },
+
+        onCompatibilityUpdateAvailable: function(addon2) {
+          if ("compatibilityUpdate" in result) {
+            throw new Error("Saw multiple compatibility update events");
+          }
+          equal(addon, addon2, "onCompatibilityUpdateAvailable");
+          result.compatibilityUpdate = true;
+        },
+
+        onNoUpdateAvailable: function(addon2) {
+          if ("updateAvailable" in result) {
+            throw new Error("Saw multiple update available events");
+          }
+          equal(addon, addon2, "onNoUpdateAvailable");
+          result.updateAvailable = false;
+        },
+
+        onUpdateAvailable: function(addon2, install) {
+          if ("updateAvailable" in result) {
+            throw new Error("Saw multiple update available events");
+          }
+          equal(addon, addon2, "onUpdateAvailable");
+          result.updateAvailable = install;
+        },
+
+        onUpdateFinished: function(addon2, error) {
+          equal(addon, addon2, "onUpdateFinished");
+          if (error == AddonManager.UPDATE_STATUS_NO_ERROR) {
+            resolve(result);
+          } else {
+            result.error = error;
+            reject(result);
+          }
+        }
+      }, reason);
+    });
+  },
+
+  /**
+   * A promise-based variant of AddonManager.getAddonsWithOperationsByTypes
+   *
+   * @param {Array<string>} types
+   *        The first argument to AddonManager.getAddonsWithOperationsByTypes
+   * @return {Promise<Array<Addon>>}
+   *        Resolves to an array of add-ons with the given operations
+   *        pending.
+   */
+  promiseAddonsWithOperationsByTypes(types) {
+    return new Promise(resolve => AddonManager.getAddonsWithOperationsByTypes(types, resolve));
+  },
+
+  /**
+   * Monitors console output for the duration of a task, and returns a promise
+   * which resolves to a tuple containing a list of all console messages
+   * generated during the task's execution, and the result of the task itself.
+   *
+   * @param {function} task
+   *        The task to run while monitoring console output. May be
+   *        either a generator function, per Task.jsm, or an ordinary
+   *        function which returns promose.
+   * @return {Promise<[Array<nsIConsoleMessage>, *]>}
+   *        Resolves to an object containing a `messages` property, with
+   *        the array of console messages emitted during the execution
+   *        of the task, and a `result` property, containing the task's
+   *        return value.
+   */
+  promiseConsoleOutput: Task.async(function*(task) {
+    const DONE = "=== xpcshell test console listener done ===";
+
+    let listener, messages = [];
+    let awaitListener = new Promise(resolve => {
+      listener = msg => {
+        if (msg == DONE) {
+          resolve();
+        } else {
+          msg instanceof Ci.nsIScriptError;
+          messages.push(msg);
+        }
+      };
+    });
+
+    Services.console.registerListener(listener);
+    try {
+      let result = yield task();
+
+      Services.console.logStringMessage(DONE);
+      yield awaitListener;
+
+      return {messages, result};
+    } finally {
+      Services.console.unregisterListener(listener);
+    }
+  }),
+};
+
+for (let [key, val] of Object.entries(AddonTestUtils)) {
+  if (typeof val == "function")
+    AddonTestUtils[key] = val.bind(AddonTestUtils);
+}
+
+EventEmitter.decorate(AddonTestUtils);
diff --git a/toolkit/mozapps/webextensions/internal/AddonUpdateChecker.jsm b/toolkit/mozapps/webextensions/internal/AddonUpdateChecker.jsm
new file mode 100644
index 000000000..63c16737c
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/AddonUpdateChecker.jsm
@@ -0,0 +1,934 @@
+/* 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/. */
+
+/**
+ * The AddonUpdateChecker is responsible for retrieving the update information
+ * from an add-on's remote update manifest.
+ */
+
+"use strict";
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = [ "AddonUpdateChecker" ];
+
+const TIMEOUT               = 60 * 1000;
+const PREFIX_NS_RDF         = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const PREFIX_NS_EM          = "http://www.mozilla.org/2004/em-rdf#";
+const PREFIX_ITEM           = "urn:mozilla:item:";
+const PREFIX_EXTENSION      = "urn:mozilla:extension:";
+const PREFIX_THEME          = "urn:mozilla:theme:";
+const TOOLKIT_ID            = "toolkit@mozilla.org"
+const XMLURI_PARSE_ERROR    = "http://www.mozilla.org/newlayout/xml/parsererror.xml"
+
+const PREF_UPDATE_REQUIREBUILTINCERTS = "extensions.update.requireBuiltInCerts";
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManager",
+                                  "resource://gre/modules/AddonManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManagerPrivate",
+                                  "resource://gre/modules/AddonManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository",
+                                  "resource://gre/modules/addons/AddonRepository.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest",
+                                  "resource://gre/modules/ServiceRequest.jsm");
+
+
+// Shared code for suppressing bad cert dialogs.
+XPCOMUtils.defineLazyGetter(this, "CertUtils", function() {
+  let certUtils = {};
+  Components.utils.import("resource://gre/modules/CertUtils.jsm", certUtils);
+  return certUtils;
+});
+
+var gRDF = Cc["@mozilla.org/rdf/rdf-service;1"].
+           getService(Ci.nsIRDFService);
+
+Cu.import("resource://gre/modules/Log.jsm");
+const LOGGER_ID = "addons.update-checker";
+
+// Create a new logger for use by the Addons Update Checker
+// (Requires AddonManager.jsm)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+/**
+ * A serialisation method for RDF data that produces an identical string
+ * for matching RDF graphs.
+ * The serialisation is not complete, only assertions stemming from a given
+ * resource are included, multiple references to the same resource are not
+ * permitted, and the RDF prolog and epilog are not included.
+ * RDF Blob and Date literals are not supported.
+ */
+function RDFSerializer() {
+  this.cUtils = Cc["@mozilla.org/rdf/container-utils;1"].
+                getService(Ci.nsIRDFContainerUtils);
+  this.resources = [];
+}
+
+RDFSerializer.prototype = {
+  INDENT: "  ",      // The indent used for pretty-printing
+  resources: null,   // Array of the resources that have been found
+
+  /**
+   * Escapes characters from a string that should not appear in XML.
+   *
+   * @param  aString
+   *         The string to be escaped
+   * @return a string with all characters invalid in XML character data
+   *         converted to entity references.
+   */
+  escapeEntities: function(aString) {
+    aString = aString.replace(/&/g, "&amp;");
+    aString = aString.replace(/</g, "&lt;");
+    aString = aString.replace(/>/g, "&gt;");
+    return aString.replace(/"/g, "&quot;");
+  },
+
+  /**
+   * Serializes all the elements of an RDF container.
+   *
+   * @param  aDs
+   *         The RDF datasource
+   * @param  aContainer
+   *         The RDF container to output the child elements of
+   * @param  aIndent
+   *         The current level of indent for pretty-printing
+   * @return a string containing the serialized elements.
+   */
+  serializeContainerItems: function(aDs, aContainer, aIndent) {
+    var result = "";
+    var items = aContainer.GetElements();
+    while (items.hasMoreElements()) {
+      var item = items.getNext().QueryInterface(Ci.nsIRDFResource);
+      result += aIndent + "<RDF:li>\n"
+      result += this.serializeResource(aDs, item, aIndent + this.INDENT);
+      result += aIndent + "</RDF:li>\n"
+    }
+    return result;
+  },
+
+  /**
+   * Serializes all em:* (see EM_NS) properties of an RDF resource except for
+   * the em:signature property. As this serialization is to be compared against
+   * the manifest signature it cannot contain the em:signature property itself.
+   *
+   * @param  aDs
+   *         The RDF datasource
+   * @param  aResource
+   *         The RDF resource that contains the properties to serialize
+   * @param  aIndent
+   *         The current level of indent for pretty-printing
+   * @return a string containing the serialized properties.
+   * @throws if the resource contains a property that cannot be serialized
+   */
+  serializeResourceProperties: function(aDs, aResource, aIndent) {
+    var result = "";
+    var items = [];
+    var arcs = aDs.ArcLabelsOut(aResource);
+    while (arcs.hasMoreElements()) {
+      var arc = arcs.getNext().QueryInterface(Ci.nsIRDFResource);
+      if (arc.ValueUTF8.substring(0, PREFIX_NS_EM.length) != PREFIX_NS_EM)
+        continue;
+      var prop = arc.ValueUTF8.substring(PREFIX_NS_EM.length);
+      if (prop == "signature")
+        continue;
+
+      var targets = aDs.GetTargets(aResource, arc, true);
+      while (targets.hasMoreElements()) {
+        var target = targets.getNext();
+        if (target instanceof Ci.nsIRDFResource) {
+          var item = aIndent + "<em:" + prop + ">\n";
+          item += this.serializeResource(aDs, target, aIndent + this.INDENT);
+          item += aIndent + "</em:" + prop + ">\n";
+          items.push(item);
+        }
+        else if (target instanceof Ci.nsIRDFLiteral) {
+          items.push(aIndent + "<em:" + prop + ">" +
+                     this.escapeEntities(target.Value) + "</em:" + prop + ">\n");
+        }
+        else if (target instanceof Ci.nsIRDFInt) {
+          items.push(aIndent + "<em:" + prop + " NC:parseType=\"Integer\">" +
+                     target.Value + "</em:" + prop + ">\n");
+        }
+        else {
+          throw Components.Exception("Cannot serialize unknown literal type");
+        }
+      }
+    }
+    items.sort();
+    result += items.join("");
+    return result;
+  },
+
+  /**
+   * Recursively serializes an RDF resource and all resources it links to.
+   * This will only output EM_NS properties and will ignore any em:signature
+   * property.
+   *
+   * @param  aDs
+   *         The RDF datasource
+   * @param  aResource
+   *         The RDF resource to serialize
+   * @param  aIndent
+   *         The current level of indent for pretty-printing. If undefined no
+   *         indent will be added
+   * @return a string containing the serialized resource.
+   * @throws if the RDF data contains multiple references to the same resource.
+   */
+  serializeResource: function(aDs, aResource, aIndent) {
+    if (this.resources.indexOf(aResource) != -1 ) {
+      // We cannot output multiple references to the same resource.
+      throw Components.Exception("Cannot serialize multiple references to " + aResource.Value);
+    }
+    if (aIndent === undefined)
+      aIndent = "";
+
+    this.resources.push(aResource);
+    var container = null;
+    var type = "Description";
+    if (this.cUtils.IsSeq(aDs, aResource)) {
+      type = "Seq";
+      container = this.cUtils.MakeSeq(aDs, aResource);
+    }
+    else if (this.cUtils.IsAlt(aDs, aResource)) {
+      type = "Alt";
+      container = this.cUtils.MakeAlt(aDs, aResource);
+    }
+    else if (this.cUtils.IsBag(aDs, aResource)) {
+      type = "Bag";
+      container = this.cUtils.MakeBag(aDs, aResource);
+    }
+
+    var result = aIndent + "<RDF:" + type;
+    if (!gRDF.IsAnonymousResource(aResource))
+      result += " about=\"" + this.escapeEntities(aResource.ValueUTF8) + "\"";
+    result += ">\n";
+
+    if (container)
+      result += this.serializeContainerItems(aDs, container, aIndent + this.INDENT);
+
+    result += this.serializeResourceProperties(aDs, aResource, aIndent + this.INDENT);
+
+    result += aIndent + "</RDF:" + type + ">\n";
+    return result;
+  }
+}
+
+/**
+ * Sanitizes the update URL in an update item, as returned by
+ * parseRDFManifest and parseJSONManifest. Ensures that:
+ *
+ * - The URL is secure, or secured by a strong enough hash.
+ * - The security principal of the update manifest has permission to
+ *   load the URL.
+ *
+ * @param aUpdate
+ *        The update item to sanitize.
+ * @param aRequest
+ *        The XMLHttpRequest used to load the manifest.
+ * @param aHashPattern
+ *        The regular expression used to validate the update hash.
+ * @param aHashString
+ *        The human-readable string specifying which hash functions
+ *        are accepted.
+ */
+function sanitizeUpdateURL(aUpdate, aRequest, aHashPattern, aHashString) {
+  if (aUpdate.updateURL) {
+    let scriptSecurity = Services.scriptSecurityManager;
+    let principal = scriptSecurity.getChannelURIPrincipal(aRequest.channel);
+    try {
+      // This logs an error on failure, so no need to log it a second time
+      scriptSecurity.checkLoadURIStrWithPrincipal(principal, aUpdate.updateURL,
+                                                  scriptSecurity.DISALLOW_SCRIPT);
+    } catch (e) {
+      delete aUpdate.updateURL;
+      return;
+    }
+
+    if (AddonManager.checkUpdateSecurity &&
+        !aUpdate.updateURL.startsWith("https:") &&
+        !aHashPattern.test(aUpdate.updateHash)) {
+      logger.warn(`Update link ${aUpdate.updateURL} is not secure and is not verified ` +
+                  `by a strong enough hash (needs to be ${aHashString}).`);
+      delete aUpdate.updateURL;
+      delete aUpdate.updateHash;
+    }
+  }
+}
+
+/**
+ * Parses an RDF style update manifest into an array of update objects.
+ *
+ * @param  aId
+ *         The ID of the add-on being checked for updates
+ * @param  aUpdateKey
+ *         An optional update key for the add-on
+ * @param  aRequest
+ *         The XMLHttpRequest that has retrieved the update manifest
+ * @param  aManifestData
+ *         The pre-parsed manifest, as a bare XML DOM document
+ * @return an array of update objects
+ * @throws if the update manifest is invalid in any way
+ */
+function parseRDFManifest(aId, aUpdateKey, aRequest, aManifestData) {
+  if (aManifestData.documentElement.namespaceURI != PREFIX_NS_RDF) {
+    throw Components.Exception("Update manifest had an unrecognised namespace: " +
+                               aManifestData.documentElement.namespaceURI);
+  }
+
+  function EM_R(aProp) {
+    return gRDF.GetResource(PREFIX_NS_EM + aProp);
+  }
+
+  function getValue(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;
+  }
+
+  function getProperty(aDs, aSource, aProperty) {
+    return getValue(aDs.GetTarget(aSource, EM_R(aProperty), true));
+  }
+
+  function getBooleanProperty(aDs, aSource, aProperty) {
+    let propValue = aDs.GetTarget(aSource, EM_R(aProperty), true);
+    if (!propValue)
+      return undefined;
+    return getValue(propValue) == "true";
+  }
+
+  function getRequiredProperty(aDs, aSource, aProperty) {
+    let value = getProperty(aDs, aSource, aProperty);
+    if (!value)
+      throw Components.Exception("Update manifest is missing a required " + aProperty + " property.");
+    return value;
+  }
+
+  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);
+  rdfParser.parseString(ds, aRequest.channel.URI, aRequest.responseText);
+
+  // Differentiating between add-on types is deprecated
+  let extensionRes = gRDF.GetResource(PREFIX_EXTENSION + aId);
+  let themeRes = gRDF.GetResource(PREFIX_THEME + aId);
+  let itemRes = gRDF.GetResource(PREFIX_ITEM + aId);
+  let addonRes;
+  if (ds.ArcLabelsOut(extensionRes).hasMoreElements())
+    addonRes = extensionRes;
+  else if (ds.ArcLabelsOut(themeRes).hasMoreElements())
+    addonRes = themeRes;
+  else
+    addonRes = itemRes;
+
+  // If we have an update key then the update manifest must be signed
+  if (aUpdateKey) {
+    let signature = getProperty(ds, addonRes, "signature");
+    if (!signature)
+      throw Components.Exception("Update manifest for " + aId + " does not contain a required signature");
+    let serializer = new RDFSerializer();
+    let updateString = null;
+
+    try {
+      updateString = serializer.serializeResource(ds, addonRes);
+    }
+    catch (e) {
+      throw Components.Exception("Failed to generate signed string for " + aId + ". Serializer threw " + e,
+                                 e.result);
+    }
+
+    let result = false;
+
+    try {
+      let verifier = Cc["@mozilla.org/security/datasignatureverifier;1"].
+                     getService(Ci.nsIDataSignatureVerifier);
+      result = verifier.verifyData(updateString, signature, aUpdateKey);
+    }
+    catch (e) {
+      throw Components.Exception("The signature or updateKey for " + aId + " is malformed." +
+                                 "Verifier threw " + e, e.result);
+    }
+
+    if (!result)
+      throw Components.Exception("The signature for " + aId + " was not created by the add-on's updateKey");
+  }
+
+  let updates = ds.GetTarget(addonRes, EM_R("updates"), true);
+
+  // A missing updates property doesn't count as a failure, just as no avialable
+  // update information
+  if (!updates) {
+    logger.warn("Update manifest for " + aId + " did not contain an updates property");
+    return [];
+  }
+
+  if (!(updates instanceof Ci.nsIRDFResource))
+    throw Components.Exception("Missing updates property for " + addonRes.Value);
+
+  let cu = Cc["@mozilla.org/rdf/container-utils;1"].
+           getService(Ci.nsIRDFContainerUtils);
+  if (!cu.IsContainer(ds, updates))
+    throw Components.Exception("Updates property was not an RDF container");
+
+  let results = [];
+  let ctr = Cc["@mozilla.org/rdf/container;1"].
+            createInstance(Ci.nsIRDFContainer);
+  ctr.Init(ds, updates);
+  let items = ctr.GetElements();
+  while (items.hasMoreElements()) {
+    let item = items.getNext().QueryInterface(Ci.nsIRDFResource);
+    let version = getProperty(ds, item, "version");
+    if (!version) {
+      logger.warn("Update manifest is missing a required version property.");
+      continue;
+    }
+
+    logger.debug("Found an update entry for " + aId + " version " + version);
+
+    let targetApps = ds.GetTargets(item, EM_R("targetApplication"), true);
+    while (targetApps.hasMoreElements()) {
+      let targetApp = targetApps.getNext().QueryInterface(Ci.nsIRDFResource);
+
+      let appEntry = {};
+      try {
+        appEntry.id = getRequiredProperty(ds, targetApp, "id");
+        appEntry.minVersion = getRequiredProperty(ds, targetApp, "minVersion");
+        appEntry.maxVersion = getRequiredProperty(ds, targetApp, "maxVersion");
+      }
+      catch (e) {
+        logger.warn(e);
+        continue;
+      }
+
+      let result = {
+        id: aId,
+        version: version,
+        multiprocessCompatible: getBooleanProperty(ds, item, "multiprocessCompatible"),
+        updateURL: getProperty(ds, targetApp, "updateLink"),
+        updateHash: getProperty(ds, targetApp, "updateHash"),
+        updateInfoURL: getProperty(ds, targetApp, "updateInfoURL"),
+        strictCompatibility: !!getBooleanProperty(ds, targetApp, "strictCompatibility"),
+        targetApplications: [appEntry]
+      };
+
+      // The JSON update protocol requires an SHA-2 hash. RDF still
+      // supports SHA-1, for compatibility reasons.
+      sanitizeUpdateURL(result, aRequest, /^sha/, "sha1 or stronger");
+
+      results.push(result);
+    }
+  }
+  return results;
+}
+
+/**
+ * Parses an JSON update manifest into an array of update objects.
+ *
+ * @param  aId
+ *         The ID of the add-on being checked for updates
+ * @param  aUpdateKey
+ *         An optional update key for the add-on
+ * @param  aRequest
+ *         The XMLHttpRequest that has retrieved the update manifest
+ * @param  aManifestData
+ *         The pre-parsed manifest, as a JSON object tree
+ * @return an array of update objects
+ * @throws if the update manifest is invalid in any way
+ */
+function parseJSONManifest(aId, aUpdateKey, aRequest, aManifestData) {
+  if (aUpdateKey)
+    throw Components.Exception("Update keys are not supported for JSON update manifests");
+
+  let TYPE_CHECK = {
+    "array": val => Array.isArray(val),
+    "object": val => val && typeof val == "object" && !Array.isArray(val),
+  };
+
+  function getProperty(aObj, aProperty, aType, aDefault = undefined) {
+    if (!(aProperty in aObj))
+      return aDefault;
+
+    let value = aObj[aProperty];
+
+    let matchesType = aType in TYPE_CHECK ? TYPE_CHECK[aType](value) : typeof value == aType;
+    if (!matchesType)
+      throw Components.Exception(`Update manifest property '${aProperty}' has incorrect type (expected ${aType})`);
+
+    return value;
+  }
+
+  function getRequiredProperty(aObj, aProperty, aType) {
+    let value = getProperty(aObj, aProperty, aType);
+    if (value === undefined)
+      throw Components.Exception(`Update manifest is missing a required ${aProperty} property.`);
+    return value;
+  }
+
+  let manifest = aManifestData;
+
+  if (!TYPE_CHECK["object"](manifest))
+    throw Components.Exception("Root element of update manifest must be a JSON object literal");
+
+  // The set of add-ons this manifest has updates for
+  let addons = getRequiredProperty(manifest, "addons", "object");
+
+  // The entry for this particular add-on
+  let addon = getProperty(addons, aId, "object");
+
+  // A missing entry doesn't count as a failure, just as no avialable update
+  // information
+  if (!addon) {
+    logger.warn("Update manifest did not contain an entry for " + aId);
+    return [];
+  }
+
+  // The list of available updates
+  let updates = getProperty(addon, "updates", "array", []);
+
+  let results = [];
+
+  for (let update of updates) {
+    let version = getRequiredProperty(update, "version", "string");
+
+    logger.debug(`Found an update entry for ${aId} version ${version}`);
+
+    let applications = getProperty(update, "applications", "object",
+                                   { gecko: {} });
+
+    // "gecko" is currently the only supported application entry. If
+    // it's missing, skip this update.
+    if (!("gecko" in applications)) {
+      logger.debug("gecko not in application entry, skipping update of ${addon}")
+      continue;
+    }
+
+    let app = getProperty(applications, "gecko", "object");
+
+    let appEntry = {
+      id: TOOLKIT_ID,
+      minVersion: getProperty(app, "strict_min_version", "string",
+                              AddonManagerPrivate.webExtensionsMinPlatformVersion),
+      maxVersion: "*",
+    };
+
+    let result = {
+      id: aId,
+      version: version,
+      multiprocessCompatible: getProperty(update, "multiprocess_compatible", "boolean", true),
+      updateURL: getProperty(update, "update_link", "string"),
+      updateHash: getProperty(update, "update_hash", "string"),
+      updateInfoURL: getProperty(update, "update_info_url", "string"),
+      strictCompatibility: false,
+      targetApplications: [appEntry],
+    };
+
+    if ("strict_max_version" in app) {
+      if ("advisory_max_version" in app) {
+        logger.warn("Ignoring 'advisory_max_version' update manifest property for " +
+                    aId + " property since 'strict_max_version' also present");
+      }
+
+      appEntry.maxVersion = getProperty(app, "strict_max_version", "string");
+      result.strictCompatibility = appEntry.maxVersion != "*";
+    } else if ("advisory_max_version" in app) {
+      appEntry.maxVersion = getProperty(app, "advisory_max_version", "string");
+    }
+
+    // The JSON update protocol requires an SHA-2 hash. RDF still
+    // supports SHA-1, for compatibility reasons.
+    sanitizeUpdateURL(result, aRequest, /^sha(256|512):/, "sha256 or sha512");
+
+    results.push(result);
+  }
+  return results;
+}
+
+/**
+ * Starts downloading an update manifest and then passes it to an appropriate
+ * parser to convert to an array of update objects
+ *
+ * @param  aId
+ *         The ID of the add-on being checked for updates
+ * @param  aUpdateKey
+ *         An optional update key for the add-on
+ * @param  aUrl
+ *         The URL of the update manifest
+ * @param  aObserver
+ *         An observer to pass results to
+ */
+function UpdateParser(aId, aUpdateKey, aUrl, aObserver) {
+  this.id = aId;
+  this.updateKey = aUpdateKey;
+  this.observer = aObserver;
+  this.url = aUrl;
+
+  let requireBuiltIn = true;
+  try {
+    requireBuiltIn = Services.prefs.getBoolPref(PREF_UPDATE_REQUIREBUILTINCERTS);
+  }
+  catch (e) {
+  }
+
+  logger.debug("Requesting " + aUrl);
+  try {
+    this.request = new ServiceRequest();
+    this.request.open("GET", this.url, true);
+    this.request.channel.notificationCallbacks = new CertUtils.BadCertHandler(!requireBuiltIn);
+    this.request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE;
+    // Prevent the request from writing to cache.
+    this.request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
+    this.request.overrideMimeType("text/plain");
+    this.request.setRequestHeader("Moz-XPI-Update", "1", true);
+    this.request.timeout = TIMEOUT;
+    this.request.addEventListener("load", () => this.onLoad(), false);
+    this.request.addEventListener("error", () => this.onError(), false);
+    this.request.addEventListener("timeout", () => this.onTimeout(), false);
+    this.request.send(null);
+  }
+  catch (e) {
+    logger.error("Failed to request update manifest", e);
+  }
+}
+
+UpdateParser.prototype = {
+  id: null,
+  updateKey: null,
+  observer: null,
+  request: null,
+  url: null,
+
+  /**
+   * Called when the manifest has been successfully loaded.
+   */
+  onLoad: function() {
+    let request = this.request;
+    this.request = null;
+    this._doneAt = new Error("place holder");
+
+    let requireBuiltIn = true;
+    try {
+      requireBuiltIn = Services.prefs.getBoolPref(PREF_UPDATE_REQUIREBUILTINCERTS);
+    }
+    catch (e) {
+    }
+
+    try {
+      CertUtils.checkCert(request.channel, !requireBuiltIn);
+    }
+    catch (e) {
+      logger.warn("Request failed: " + this.url + " - " + e);
+      this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR);
+      return;
+    }
+
+    if (!Components.isSuccessCode(request.status)) {
+      logger.warn("Request failed: " + this.url + " - " + request.status);
+      this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR);
+      return;
+    }
+
+    let channel = request.channel;
+    if (channel instanceof Ci.nsIHttpChannel && !channel.requestSucceeded) {
+      logger.warn("Request failed: " + this.url + " - " + channel.responseStatus +
+           ": " + channel.responseStatusText);
+      this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR);
+      return;
+    }
+
+    // Detect the manifest type by first attempting to parse it as
+    // JSON, and falling back to parsing it as XML if that fails.
+    let parser;
+    try {
+      try {
+        let json = JSON.parse(request.responseText);
+
+        parser = () => parseJSONManifest(this.id, this.updateKey, request, json);
+      } catch (e) {
+        if (!(e instanceof SyntaxError))
+          throw e;
+        let domParser = Cc["@mozilla.org/xmlextras/domparser;1"].createInstance(Ci.nsIDOMParser);
+        let xml = domParser.parseFromString(request.responseText, "text/xml");
+
+        if (xml.documentElement.namespaceURI == XMLURI_PARSE_ERROR)
+          throw new Error("Update manifest was not valid XML or JSON");
+
+        parser = () => parseRDFManifest(this.id, this.updateKey, request, xml);
+      }
+    } catch (e) {
+      logger.warn("onUpdateCheckComplete failed to determine manifest type");
+      this.notifyError(AddonUpdateChecker.ERROR_UNKNOWN_FORMAT);
+      return;
+    }
+
+    let results;
+    try {
+      results = parser();
+    }
+    catch (e) {
+      logger.warn("onUpdateCheckComplete failed to parse update manifest", e);
+      this.notifyError(AddonUpdateChecker.ERROR_PARSE_ERROR);
+      return;
+    }
+
+    if ("onUpdateCheckComplete" in this.observer) {
+      try {
+        this.observer.onUpdateCheckComplete(results);
+      }
+      catch (e) {
+        logger.warn("onUpdateCheckComplete notification failed", e);
+      }
+    }
+    else {
+      logger.warn("onUpdateCheckComplete may not properly cancel", new Error("stack marker"));
+    }
+  },
+
+  /**
+   * Called when the request times out
+   */
+  onTimeout: function() {
+    this.request = null;
+    this._doneAt = new Error("Timed out");
+    logger.warn("Request for " + this.url + " timed out");
+    this.notifyError(AddonUpdateChecker.ERROR_TIMEOUT);
+  },
+
+  /**
+   * Called when the manifest failed to load.
+   */
+  onError: function() {
+    if (!Components.isSuccessCode(this.request.status)) {
+      logger.warn("Request failed: " + this.url + " - " + this.request.status);
+    }
+    else if (this.request.channel instanceof Ci.nsIHttpChannel) {
+      try {
+        if (this.request.channel.requestSucceeded) {
+          logger.warn("Request failed: " + this.url + " - " +
+               this.request.channel.responseStatus + ": " +
+               this.request.channel.responseStatusText);
+        }
+      }
+      catch (e) {
+        logger.warn("HTTP Request failed for an unknown reason");
+      }
+    }
+    else {
+      logger.warn("Request failed for an unknown reason");
+    }
+
+    this.request = null;
+    this._doneAt = new Error("UP_onError");
+
+    this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR);
+  },
+
+  /**
+   * Helper method to notify the observer that an error occured.
+   */
+  notifyError: function(aStatus) {
+    if ("onUpdateCheckError" in this.observer) {
+      try {
+        this.observer.onUpdateCheckError(aStatus);
+      }
+      catch (e) {
+        logger.warn("onUpdateCheckError notification failed", e);
+      }
+    }
+  },
+
+  /**
+   * Called to cancel an in-progress update check.
+   */
+  cancel: function() {
+    if (!this.request) {
+      logger.error("Trying to cancel already-complete request", this._doneAt);
+      return;
+    }
+    this.request.abort();
+    this.request = null;
+    this._doneAt = new Error("UP_cancel");
+    this.notifyError(AddonUpdateChecker.ERROR_CANCELLED);
+  }
+};
+
+/**
+ * Tests if an update matches a version of the application or platform
+ *
+ * @param  aUpdate
+ *         The available update
+ * @param  aAppVersion
+ *         The application version to use
+ * @param  aPlatformVersion
+ *         The platform version to use
+ * @param  aIgnoreMaxVersion
+ *         Ignore maxVersion when testing if an update matches. Optional.
+ * @param  aIgnoreStrictCompat
+ *         Ignore strictCompatibility when testing if an update matches. Optional.
+ * @param  aCompatOverrides
+ *         AddonCompatibilityOverride objects to match against. Optional.
+ * @return true if the update is compatible with the application/platform
+ */
+function matchesVersions(aUpdate, aAppVersion, aPlatformVersion,
+                         aIgnoreMaxVersion, aIgnoreStrictCompat,
+                         aCompatOverrides) {
+  if (aCompatOverrides) {
+    let override = AddonRepository.findMatchingCompatOverride(aUpdate.version,
+                                                              aCompatOverrides,
+                                                              aAppVersion,
+                                                              aPlatformVersion);
+    if (override && override.type == "incompatible")
+      return false;
+  }
+
+  if (aUpdate.strictCompatibility && !aIgnoreStrictCompat)
+    aIgnoreMaxVersion = false;
+
+  let result = false;
+  for (let app of aUpdate.targetApplications) {
+    if (app.id == Services.appinfo.ID) {
+      return (Services.vc.compare(aAppVersion, app.minVersion) >= 0) &&
+             (aIgnoreMaxVersion || (Services.vc.compare(aAppVersion, app.maxVersion) <= 0));
+    }
+    if (app.id == TOOLKIT_ID) {
+      result = (Services.vc.compare(aPlatformVersion, app.minVersion) >= 0) &&
+               (aIgnoreMaxVersion || (Services.vc.compare(aPlatformVersion, app.maxVersion) <= 0));
+    }
+  }
+  return result;
+}
+
+this.AddonUpdateChecker = {
+  // These must be kept in sync with AddonManager
+  // The update check timed out
+  ERROR_TIMEOUT: -1,
+  // There was an error while downloading the update information.
+  ERROR_DOWNLOAD_ERROR: -2,
+  // The update information was malformed in some way.
+  ERROR_PARSE_ERROR: -3,
+  // The update information was not in any known format.
+  ERROR_UNKNOWN_FORMAT: -4,
+  // The update information was not correctly signed or there was an SSL error.
+  ERROR_SECURITY_ERROR: -5,
+  // The update was cancelled
+  ERROR_CANCELLED: -6,
+
+  /**
+   * Retrieves the best matching compatibility update for the application from
+   * a list of available update objects.
+   *
+   * @param  aUpdates
+   *         An array of update objects
+   * @param  aVersion
+   *         The version of the add-on to get new compatibility information for
+   * @param  aIgnoreCompatibility
+   *         An optional parameter to get the first compatibility update that
+   *         is compatible with any version of the application or toolkit
+   * @param  aAppVersion
+   *         The version of the application or null to use the current version
+   * @param  aPlatformVersion
+   *         The version of the platform or null to use the current version
+   * @param  aIgnoreMaxVersion
+   *         Ignore maxVersion when testing if an update matches. Optional.
+   * @param  aIgnoreStrictCompat
+   *         Ignore strictCompatibility when testing if an update matches. Optional.
+   * @return an update object if one matches or null if not
+   */
+  getCompatibilityUpdate: function(aUpdates, aVersion, aIgnoreCompatibility,
+                                   aAppVersion, aPlatformVersion,
+                                   aIgnoreMaxVersion, aIgnoreStrictCompat) {
+    if (!aAppVersion)
+      aAppVersion = Services.appinfo.version;
+    if (!aPlatformVersion)
+      aPlatformVersion = Services.appinfo.platformVersion;
+
+    for (let update of aUpdates) {
+      if (Services.vc.compare(update.version, aVersion) == 0) {
+        if (aIgnoreCompatibility) {
+          for (let targetApp of update.targetApplications) {
+            let id = targetApp.id;
+            if (id == Services.appinfo.ID || id == TOOLKIT_ID)
+              return update;
+          }
+        }
+        else if (matchesVersions(update, aAppVersion, aPlatformVersion,
+                                 aIgnoreMaxVersion, aIgnoreStrictCompat)) {
+          return update;
+        }
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Returns the newest available update from a list of update objects.
+   *
+   * @param  aUpdates
+   *         An array of update objects
+   * @param  aAppVersion
+   *         The version of the application or null to use the current version
+   * @param  aPlatformVersion
+   *         The version of the platform or null to use the current version
+   * @param  aIgnoreMaxVersion
+   *         When determining compatible updates, ignore maxVersion. Optional.
+   * @param  aIgnoreStrictCompat
+   *         When determining compatible updates, ignore strictCompatibility. Optional.
+   * @param  aCompatOverrides
+   *         Array of AddonCompatibilityOverride to take into account. Optional.
+   * @return an update object if one matches or null if not
+   */
+  getNewestCompatibleUpdate: function(aUpdates, aAppVersion, aPlatformVersion,
+                                      aIgnoreMaxVersion, aIgnoreStrictCompat,
+                                      aCompatOverrides) {
+    if (!aAppVersion)
+      aAppVersion = Services.appinfo.version;
+    if (!aPlatformVersion)
+      aPlatformVersion = Services.appinfo.platformVersion;
+
+    let blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
+                    getService(Ci.nsIBlocklistService);
+
+    let newest = null;
+    for (let update of aUpdates) {
+      if (!update.updateURL)
+        continue;
+      let state = blocklist.getAddonBlocklistState(update, aAppVersion, aPlatformVersion);
+      if (state != Ci.nsIBlocklistService.STATE_NOT_BLOCKED)
+        continue;
+      if ((newest == null || (Services.vc.compare(newest.version, update.version) < 0)) &&
+          matchesVersions(update, aAppVersion, aPlatformVersion,
+                          aIgnoreMaxVersion, aIgnoreStrictCompat,
+                          aCompatOverrides)) {
+        newest = update;
+      }
+    }
+    return newest;
+  },
+
+  /**
+   * Starts an update check.
+   *
+   * @param  aId
+   *         The ID of the add-on being checked for updates
+   * @param  aUpdateKey
+   *         An optional update key for the add-on
+   * @param  aUrl
+   *         The URL of the add-on's update manifest
+   * @param  aObserver
+   *         An observer to notify of results
+   * @return UpdateParser so that the caller can use UpdateParser.cancel() to shut
+   *         down in-progress update requests
+   */
+  checkForUpdates: function(aId, aUpdateKey, aUrl, aObserver) {
+    return new UpdateParser(aId, aUpdateKey, aUrl, aObserver);
+  }
+};
diff --git a/toolkit/mozapps/webextensions/internal/Content.js b/toolkit/mozapps/webextensions/internal/Content.js
new file mode 100644
index 000000000..9f366ba32
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/Content.js
@@ -0,0 +1,38 @@
+/* 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/. */
+
+/* globals addMessageListener*/
+
+"use strict";
+
+(function() {
+
+var {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+
+var {Services} = Cu.import("resource://gre/modules/Services.jsm", {});
+
+var nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile",
+                                     "initWithPath");
+
+const MSG_JAR_FLUSH = "AddonJarFlush";
+const MSG_MESSAGE_MANAGER_CACHES_FLUSH = "AddonMessageManagerCachesFlush";
+
+
+try {
+  if (Services.appinfo.processType !== Services.appinfo.PROCESS_TYPE_DEFAULT) {
+    // Propagate JAR cache flush notifications across process boundaries.
+    addMessageListener(MSG_JAR_FLUSH, function(message) {
+      let file = new nsIFile(message.data);
+      Services.obs.notifyObservers(file, "flush-cache-entry", null);
+    });
+    // Propagate message manager caches flush notifications across processes.
+    addMessageListener(MSG_MESSAGE_MANAGER_CACHES_FLUSH, function() {
+      Services.obs.notifyObservers(null, "message-manager-flush-caches", null);
+    });
+  }
+} catch (e) {
+  Cu.reportError(e);
+}
+
+})();
diff --git a/toolkit/mozapps/webextensions/internal/E10SAddonsRollout.jsm b/toolkit/mozapps/webextensions/internal/E10SAddonsRollout.jsm
new file mode 100644
index 000000000..3bcee44d3
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/E10SAddonsRollout.jsm
@@ -0,0 +1,982 @@
+/* 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";
+
+this.EXPORTED_SYMBOLS = [ "isAddonPartOfE10SRollout" ];
+
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/Preferences.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+
+const PREF_E10S_ADDON_BLOCKLIST = "extensions.e10s.rollout.blocklist";
+const PREF_E10S_ADDON_POLICY    = "extensions.e10s.rollout.policy";
+
+const ADDONS = {
+  "Greasemonkey": { // Greasemonkey
+    id: "{e4a8a97b-f2ed-450b-b12d-ee082ba24781}", minVersion: "3.8",
+  },
+
+  "DYTV": { // Download YouTube Videos as MP4
+    id: "{b9bfaf1c-a63f-47cd-8b9a-29526ced9060}", minVersion: "1.8.7",
+  },
+
+  "VDH": { // Video Download Helper
+    id: "{b9db16a4-6edc-47ec-a1f4-b86292ed211d}", minVersion: "5.6.1",
+  },
+
+  "Lightbeam": { // Lightbeam
+    id: "jid1-F9UJ2thwoAm5gQ@jetpack", minVersion: "1.3.0.1",
+  },
+
+  "ABP": { // Adblock Plus
+    id: "{d10d0bf8-f5b5-c8b4-a8b2-2b9879e08c5d}", minVersion: "2.7.3",
+  },
+
+  "uBlockOrigin": { // uBlock Origin
+    id: "uBlock0@raymondhill.net", minVersion: "1.7.6",
+  },
+
+  "Emoji": { // Emoji Cheatsheet
+    id: "jid1-Xo5SuA6qc1DFpw@jetpack", minVersion: "1.1.1",
+  },
+
+  "ASP": { // Awesome Screenshot Plus
+    id: "jid0-GXjLLfbCoAx0LcltEdFrEkQdQPI@jetpack", minVersion: "3.0.10",
+  },
+
+  "PersonasPlus": { // PersonasPlus
+    id: "personas@christopher.beard", minVersion: "1.8.0",
+  },
+
+  "ACR": { // Add-on Compatibility Reporter
+    id: "compatibility@addons.mozilla.org", minVersion: "2.2.0",
+  },
+
+  // Add-ons used for testing
+  "test1": {
+    id: "bootstrap1@tests.mozilla.org", minVersion: "1.0",
+  },
+
+  "test2": {
+    id: "bootstrap2@tests.mozilla.org", minVersion: "1.0",
+  },
+};
+
+// NOTE: Do not modify sets or policies after they have already been
+// published to users. They must remain unchanged to provide valid data.
+
+// Set 2 used during 48 Beta cycle. Kept here for historical reasons.
+const set2 = [ADDONS.Greasemonkey,
+              ADDONS.DYTV,
+              ADDONS.VDH,
+              ADDONS.Lightbeam,
+              ADDONS.ABP,
+              ADDONS.uBlockOrigin,
+              ADDONS.Emoji,
+              ADDONS.ASP,
+              ADDONS.PersonasPlus];
+
+const set49Release = [
+  ADDONS.Greasemonkey,
+  ADDONS.DYTV,
+  ADDONS.VDH,
+  ADDONS.Lightbeam,
+  ADDONS.ABP,
+  ADDONS.uBlockOrigin,
+  ADDONS.Emoji,
+  ADDONS.ASP,
+  ADDONS.PersonasPlus,
+  ADDONS.ACR
+];
+
+// These are only the add-ons in the Add-Ons Manager Discovery
+// pane. This set is here in case we need to reduce add-ons
+// exposure live on Release.
+const set49PaneOnly = [
+  ADDONS.ABP,
+  ADDONS.VDH,
+  ADDONS.Emoji,
+  ADDONS.ASP,
+  ADDONS.ACR
+]
+
+// ================== ADDONS FOR 51 RELEASE ==================
+//
+// During the 51 beta cycle, we tested e10s with all addons
+// except those explicitly marked as being incompatible.
+// For release, instead of opening this up, we assembled
+// the lists below with all addons that were seen on beta
+// and had over 50 installs.
+//
+// This list is in a new format to allow fast access and also
+// to allow controlling by the number of addons installed.
+
+const set51Release = {
+  "_65Members_@download.fromdoctopdf.com": {minVersion: "7.102.10.4221", installs: 32092},
+  "light_plugin_ACF0E80077C511E59DED005056C00008@kaspersky.com": {minVersion: "4.6.3-15", installs: 27758},
+  "_ceMembers_@free.easypdfcombine.com": {minVersion: "7.102.10.4117", installs: 17797},
+  "caa1-aDOiCAxFFMOVIX@jetpack": {minVersion: "0.1.7", installs: 13150},
+  "{4ED1F68A-5463-4931-9384-8FFF5ED91D92}": {minVersion: "5.0.248.0", installs: 12774},
+  "_dbMembers_@free.getformsonline.com": {minVersion: "7.102.10.4251", installs: 11909},
+  "_4zMembers_@www.videodownloadconverter.com": {minVersion: "7.102.10.5033", installs: 11612},
+  "light_plugin_F6F079488B53499DB99380A7E11A93F6@kaspersky.com": {minVersion: "5.0.141-4-20161031140250", installs: 10944},
+  "YoutubeDownloader@PeterOlayev.com": {minVersion: "2.4.1", installs: 10722},
+  "{82AF8DCA-6DE9-405D-BD5E-43525BDAD38A}": {minVersion: "8.0.0.9103", installs: 8856},
+  "client@anonymox.net": {minVersion: "2.5.2", installs: 8225},
+  "_8hMembers_@download.allin1convert.com": {minVersion: "7.102.10.3584", installs: 7681},
+  "light_plugin_D772DC8D6FAF43A29B25C4EBAA5AD1DE@kaspersky.com": {minVersion: "4.6.2-42-20160922074409", installs: 7177},
+  "_dzMembers_@www.pconverter.com": {minVersion: "7.102.10.4851", installs: 7115},
+  "fxdevtools-adapters@mozilla.org": {minVersion: "0.3.5", installs: 6926},
+  "_9pMembers_@free.onlinemapfinder.com": {minVersion: "7.102.10.4836", installs: 6583},
+  "@DownloadManager": {minVersion: "0.2.1", installs: 6412},
+  "ar1er-ewrgfdgomusix@jetpack": {minVersion: "1.0.6", installs: 5975},
+  "_agMembers_@free.premierdownloadmanager.com": {minVersion: "7.102.10.4846", installs: 5605},
+  "_paMembers_@www.filmfanatic.com": {minVersion: "7.102.10.4163", installs: 5448},
+  "_gtMembers_@free.gamingwonderland.com": {minVersion: "7.102.10.4263", installs: 5241},
+  "LVD-SAE@iacsearchandmedia.com": {minVersion: "8.5", installs: 4694},
+  "_fsMembers_@free.pdfconverterhq.com": {minVersion: "7.102.10.4849", installs: 4526},
+  "_6xMembers_@www.readingfanatic.com": {minVersion: "7.102.10.4914", installs: 4417},
+  "@mysmartprice-ff": {minVersion: "0.0.6", installs: 4381},
+  "jid1-YcMV6ngYmQRA2w@jetpack": {minVersion: "1.37.9", installs: 3899},
+  "{58d735b4-9d6c-4e37-b146-7b9f7e79e318}": {minVersion: "1.6", installs: 3733},
+  "anttoolbar@ant.com": {minVersion: "2.4.7.47", installs: 3720},
+  "adblockpopups@jessehakanen.net": {minVersion: "0.9.2.1-signed.1-signed", installs: 3602},
+  "ERAIL.IN.FFPLUGIN@jetpack": {minVersion: "6.0.rev142", installs: 3545},
+  "WebProtection@360safe.com": {minVersion: "5.0.0.1005", installs: 3475},
+  "yasearch@yandex.ru": {minVersion: "8.20.4", installs: 3299},
+  "{19503e42-ca3c-4c27-b1e2-9cdb2170ee34}": {minVersion: "1.5.6.14", installs: 3106},
+  "{C1A2A613-35F1-4FCF-B27F-2840527B6556}": {minVersion: "2016.8.1.9", installs: 3083},
+  "_b7Members_@free.mytransitguide.com": {minVersion: "7.102.10.4812", installs: 3011},
+  "_9tMembers_@free.internetspeedtracker.com": {minVersion: "7.102.10.4339", installs: 2828},
+  "_64Members_@www.televisionfanatic.com": {minVersion: "7.102.10.4968", installs: 2821},
+  "info@youtube-mp3.org": {minVersion: "1.0.9.1-signed.1-signed", installs: 2717},
+  "ffext_basicvideoext@startpage24": {minVersion: "1.97.37.1-signed.1-signed", installs: 2663},
+  "MUB-SAE@iacsearchandmedia.com": {minVersion: "8.7", installs: 2650},
+  "_4jMembers_@www.radiorage.com": {minVersion: "7.102.10.4916", installs: 2631},
+  "@Email": {minVersion: "4.0.12", installs: 2583},
+  "_gcMembers_@www.weatherblink.com": {minVersion: "7.38.8.56523", installs: 2519},
+  "_dqMembers_@www.downspeedtest.com": {minVersion: "7.102.10.3827", installs: 2445},
+  "translator@zoli.bod": {minVersion: "2.1.0.5.1.1-signed", installs: 2310},
+  "{a38384b3-2d1d-4f36-bc22-0f7ae402bcd7}": {minVersion: "1.0.0.51", installs: 2190},
+  "_1eMembers_@www.videoscavenger.com": {minVersion: "7.38.8.45273", installs: 2185},
+  "tvplusnewtab-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 2155},
+  "homepage@mail.ru": {minVersion: "1.0.2", installs: 2124},
+  "search@mail.ru": {minVersion: "1.0.7", installs: 2038},
+  "_69Members_@www.packagetracer.com": {minVersion: "7.102.10.4831", installs: 2036},
+  "{7b8a500a-a464-4624-bd4f-73eaafe0f766}": {minVersion: "3", installs: 2027},
+  "paulsaintuzb@gmail.com": {minVersion: "8.2.1", installs: 2005},
+  "k7srff_enUS@k7computing.com": {minVersion: "2.4", installs: 1929},
+  "_e5Members_@www.productivityboss.com": {minVersion: "7.38.8.46590", installs: 1892},
+  "vdpure@link64": {minVersion: "1.97.43", installs: 1860},
+  "_9tMembers_@download.internetspeedtracker.com": {minVersion: "7.38.8.56171", installs: 1824},
+  "_g3Members_@free.easyphotoedit.com": {minVersion: "7.102.10.4108", installs: 1822},
+  "_64Members_@download.televisionfanatic.com": {minVersion: "7.38.9.3004", installs: 1730},
+  "_8iMembers_@download.audiotoaudio.com": {minVersion: "7.102.10.3585", installs: 1704},
+  "adblockultimate@adblockultimate.net": {minVersion: "2.25", installs: 1648},
+  "eagleget_ffext@eagleget.com": {minVersion: "3.8", installs: 1640},
+  "_9eMembers_@free.findmefreebies.com": {minVersion: "7.102.10.4193", installs: 1638},
+  "content_blocker_663BE8@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1625},
+  "virtual_keyboard_074028@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1624},
+  "browsec@browsec.com": {minVersion: "2.0.3", installs: 1610},
+  "@Maps": {minVersion: "4.0.0", installs: 1587},
+  "_exMembers_@free.easydocmerge.com": {minVersion: "7.102.10.4137", installs: 1493},
+  "{635abd67-4fe9-1b23-4f01-e679fa7484c1}": {minVersion: "5.0.2", installs: 1490},
+  "abb@amazon.com": {minVersion: "10.1612.1.304", installs: 1463},
+  "{1BC9BA34-1EED-42ca-A505-6D2F1A935BBB}": {minVersion: "6.2.18.1", installs: 1436},
+  "mp4downloader@jeff.net": {minVersion: "1.3.3.1-signed.1-signed", installs: 1410},
+  "jid1-16aeif9OQIRKxA@jetpack": {minVersion: "1.1.4", installs: 1399},
+  "{c45c406e-ab73-11d8-be73-000a95be3b12}": {minVersion: "1.2.11", installs: 1367},
+  "online_banking_08806E@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1356},
+  "_ewMembers_@free.mergedocsonline.com": {minVersion: "7.102.10.4710", installs: 1337},
+  "@DiscreteSearch": {minVersion: "0.2.1", installs: 1306},
+  "{6AC85730-7D0F-4de0-B3FA-21142DD85326}": {minVersion: "2.8.2", installs: 1286},
+  "{063DA41A-2561-401B-91FA-AC75E460F4EB}": {minVersion: "1.0.7.1", installs: 1280},
+  "netvideohunter@netvideohunter.com": {minVersion: "1.2", installs: 1260},
+  "_8eMembers_@download.howtosimplified.com": {minVersion: "7.102.10.4285", installs: 1230},
+  "FGZ-SAE@iacsearchandmedia.com": {minVersion: "8.5", installs: 1220},
+  "adguardadblocker@adguard.com": {minVersion: "2.4.14", installs: 1172},
+  "_39Members_@www.mapsgalaxy.com": {minVersion: "7.102.10.4730", installs: 1171},
+  "_euMembers_@free.filesendsuite.com": {minVersion: "7.102.10.4154", installs: 1166},
+  "_brMembers_@free.yourtemplatefinder.com": {minVersion: "7.102.10.5047", installs: 1159},
+  "_8jMembers_@download.myimageconverter.com": {minVersion: "7.102.10.4778", installs: 1150},
+  "_12Members_@free.myscrapnook.com": {minVersion: "7.102.10.4739", installs: 1113},
+  "_7eMembers_@www.homeworksimplified.com": {minVersion: "7.102.10.4290", installs: 1109},
+  "{fe272bd1-5f76-4ea4-8501-a05d35d823fc}": {minVersion: "2.1.9.1-signed.1-let-fixed.1-signed", installs: 1108},
+  "_frMembers_@free.testforspeed.com": {minVersion: "7.102.10.4993", installs: 1107},
+  "{068e178c-61a9-4a63-b74f-87404a6f5ea1}": {minVersion: "2", installs: 1104},
+  "@Package": {minVersion: "0.2.0", installs: 1092},
+  "6asa42dfa4784fsf368g@youtubeconverter.me": {minVersion: "0.1", installs: 1071},
+  "_diMembers_@www.free.easymaillogin.com": {minVersion: "7.102.10.4112", installs: 1043},
+  "_v4Members_@www.dictionaryboss.com": {minVersion: "7.102.10.3797", installs: 1035},
+  "colorPicker@colorPicker": {minVersion: "3.0.1-signed.1-signed", installs: 1023},
+  "hotspot-shield@anchorfree.com": {minVersion: "1.2.87", installs: 1000},
+  "manishjain9@hotmail.com_easiestyoutube": {minVersion: "7.2.1-signed.1-let-fixed.1-signed", installs: 993},
+  "{cd617375-6743-4ee8-bac4-fbf10f35729e}": {minVersion: "2.9.6", installs: 987},
+  "@Converter": {minVersion: "4.1.0", installs: 986},
+  "{dd3d7613-0246-469d-bc65-2a3cc1668adc}": {minVersion: "1.1.8.1-signed.1-signed", installs: 983},
+  "ubufox@ubuntu.com": {minVersion: "3.2", installs: 950},
+  "jid1-lpoiffmusixlib@jetpack": {minVersion: "0.1.9", installs: 945},
+  "_5aMembers_@download.mywebface.com": {minVersion: "7.102.10.4837", installs: 930},
+  "leethax@leethax.net": {minVersion: "2016.12.02", installs: 930},
+  "{1A2D0EC4-75F5-4c91-89C4-3656F6E44B68}": {minVersion: "0.6.3.1-signed.1-signed", installs: 885},
+  "{64161300-e22b-11db-8314-0800200c9a66}": {minVersion: "0.9.6.18", installs: 875},
+  "_bfMembers_@free.snapmyscreen.com": {minVersion: "7.102.10.4951", installs: 827},
+  "uriloader@pdf.js": {minVersion: "1.0.277.1-signed.1-signed", installs: 815},
+  "{e968fc70-8f95-4ab9-9e79-304de2a71ee1}": {minVersion: "0.7.3.1-signed.1-signed", installs: 805},
+  "save-as-pdf-ff@pdfcrowd.com": {minVersion: "1.5.1-signed.1-signed", installs: 804},
+  "{75CEEE46-9B64-46f8-94BF-54012DE155F0}": {minVersion: "0.4.15", installs: 794},
+  "safesearchplus2@avira.com": {minVersion: "1.4.1.371", installs: 786},
+  "easyscreenshot@mozillaonline.com": {minVersion: "1.2.8", installs: 785},
+  "_eeMembers_@download.freeradiocast.com": {minVersion: "7.38.8.46366", installs: 783},
+  "_89Members_@download.safepcrepair.com": {minVersion: "7.39.8.51080", installs: 777},
+  "{a3a5c777-f583-4fef-9380-ab4add1bc2a5}": {minVersion: "2.4.2.1-signed", installs: 771},
+  "content_blocker@kaspersky.com": {minVersion: "4.0.10.15", installs: 770},
+  "safesearch@avira.com": {minVersion: "1.4.1.371", installs: 767},
+  "youtube2mp3@mondayx.de": {minVersion: "1.2.3.1-signed.1-signed", installs: 748},
+  "2020Player_IKEA@2020Technologies.com": {minVersion: "5.0.94.1", installs: 736},
+  "_edMembers_@free.myradioaccess.com": {minVersion: "7.102.10.4797", installs: 734},
+  "_dmMembers_@free.gounzip.com": {minVersion: "7.102.10.4277", installs: 733},
+  "Media-Newtab-the-extension1@mozilla.com": {minVersion: "0.1.6", installs: 732},
+  "foxmarks@kei.com": {minVersion: "4.3.19", installs: 728},
+  "{e8deb9e5-5688-4655-838a-b7a121a9f16e}": {minVersion: "48.4", installs: 726},
+  "{195A3098-0BD5-4e90-AE22-BA1C540AFD1E}": {minVersion: "4.1.0.1-signed.1-signed", installs: 722},
+  "jid1-4P0kohSJxU1qGg@jetpack": {minVersion: "1.22.550", installs: 719},
+  "DailymotionVideoDownloader@PeterOlayev.com": {minVersion: "1.0.6.1-signed.1-signed", installs: 717},
+  "jid1-P34HaABBBpOerQ@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 715},
+  "SQLiteManager@mrinalkant.blogspot.com": {minVersion: "0.8.3.1-signed.1-signed", installs: 700},
+  "2.0@disconnect.me": {minVersion: "3.15.3.1-signed.1-signed", installs: 693},
+  "multifox@hultmann": {minVersion: "3.2.3", installs: 690},
+  "_5mMembers_@download.myfuncards.com": {minVersion: "7.102.10.4783", installs: 679},
+  "_btMembers_@free.catsandcatapults.com": {minVersion: "7.102.10.3677", installs: 673},
+  "pavel.sherbakov@gmail.com": {minVersion: "19.1.1", installs: 666},
+  "_fbMembers_@free.smarterpassword.com": {minVersion: "7.102.10.4936", installs: 644},
+  "jid2-l8SPBzHJWBIiHQ@jetpack": {minVersion: "3.1", installs: 639},
+  "{B17C1C5A-04B1-11DB-9804-B622A1EF5492}": {minVersion: "1.3.2", installs: 633},
+  "myplaycitycom@gametab": {minVersion: "1.6", installs: 616},
+  "{ad0d925d-88f8-47f1-85ea-8463569e756e}": {minVersion: "2.0.5", installs: 604},
+  "{37964A3C-4EE8-47b1-8321-34DE2C39BA4D}": {minVersion: "2.5.4.174", installs: 603},
+  "youtubemp3podcaster@jeremy.d.gregorio.com": {minVersion: "3.9.0", installs: 601},
+  "caa1-aDOiCAxFFPRIVATE@jetpack": {minVersion: "0.2.0", installs: 598},
+  "_f5Members_@free.typingfanatic.com": {minVersion: "7.102.10.5014", installs: 595},
+  "_94Members_@www.motitags.com": {minVersion: "7.102.10.4744", installs: 594},
+  "{888d99e7-e8b5-46a3-851e-1ec45da1e644}": {minVersion: "45.0.0", installs: 581},
+  "_1cMembers_@www.bringmesports.com": {minVersion: "7.102.10.3646", installs: 580},
+  "{a6fd85ed-e919-4a43-a5af-8da18bda539f}": {minVersion: "2.9.1.1-signed", installs: 572},
+  "{0fc22c4c-93ed-48ea-ad12-dc8039cf3795}": {minVersion: "1.3", installs: 568},
+  "homeutil@yandex.ru": {minVersion: "1.0.13", installs: 565},
+  "_doMembers_@free.convertanyfile.com": {minVersion: "7.38.8.45860", installs: 563},
+  "SocialNewPages-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 561},
+  "wappalyzer@crunchlabz.com": {minVersion: "3.2.7", installs: 557},
+  "_5qMembers_@www.zwinky.com": {minVersion: "7.38.8.45270", installs: 551},
+  "{0545b830-f0aa-4d7e-8820-50a4629a56fe}": {minVersion: "31.0.9", installs: 531},
+  "vk@sergeykolosov.mp": {minVersion: "0.3.9.5", installs: 522},
+  "{77b819fa-95ad-4f2c-ac7c-486b356188a9}": {minVersion: "4.0.20130422.1-signed.1-signed", installs: 505},
+  "@true-key": {minVersion: "1.23.0.2433", installs: 501},
+  "_1pMembers_@www.referenceboss.com": {minVersion: "7.102.10.4932", installs: 499},
+  "{C7AE725D-FA5C-4027-BB4C-787EF9F8248A}": {minVersion: "1.0.0.4", installs: 494},
+  "alx-ffdeveloper@amazon.com": {minVersion: "3.0.2", installs: 493},
+  "{3d7eb24f-2740-49df-8937-200b1cc08f8a}": {minVersion: "1.5.20", installs: 491},
+  "_1gMembers_@www.inboxace.com": {minVersion: "7.38.8.56535", installs: 488},
+  "{7DD78D43-0962-4d9b-BC76-ABF13B3B2ED1}": {minVersion: "3.5.0.1428", installs: 484},
+  "imageblock@hemantvats.com": {minVersion: "3.1", installs: 472},
+  "online_banking@kaspersky.com": {minVersion: "4.0.10.15", installs: 463},
+  "virtual_keyboard@kaspersky.com": {minVersion: "4.0.10.15", installs: 463},
+  "button@scholar.google.com": {minVersion: "1.1.1-signed.1-signed", installs: 463},
+  "anti_banner@kaspersky.com": {minVersion: "4.0.10.15", installs: 462},
+  "url_advisor@kaspersky.com": {minVersion: "4.0.10.15", installs: 461},
+  "{6d96bb5e-1175-4ebf-8ab5-5f56f1c79f65}": {minVersion: "0.9.8", installs: 457},
+  "_14Members_@download.totalrecipesearch.com": {minVersion: "7.102.10.4983", installs: 456},
+  "{394DCBA4-1F92-4f8e-8EC9-8D2CB90CB69B}": {minVersion: "5.1.1", installs: 447},
+  "_57Members_@free.marineaquariumfree.com": {minVersion: "7.102.10.4716", installs: 446},
+  "e67f8350-7edf-11e3-baa7-0800200c9a66@fri-gate.org": {minVersion: "2.2.1.1-signed", installs: 446},
+  "FireXPath@pierre.tholence.com": {minVersion: "0.9.7.1.1-signed.1-signed", installs: 442},
+  "@youtube_downloader": {minVersion: "0.0.9", installs: 435},
+  "ff_hpset@jetpack": {minVersion: "1.0.8", installs: 428},
+  "{d0bfdcce-52c7-4b32-bb45-948f62db8d3f}": {minVersion: "49.1", installs: 406},
+  "_j2Members_@www.soccerinferno.com": {minVersion: "7.102.10.4948", installs: 405},
+  "autoform@olifozzy": {minVersion: "1.2.4.1-signed.1-signed", installs: 405},
+  "FunSafeTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 405},
+  "testpilot@labs.mozilla.com": {minVersion: "1.2.3.1-signed", installs: 405},
+  "vwof@drev.com": {minVersion: "3.1.2", installs: 401},
+  "_ftMembers_@free.mytelevisionhq.com": {minVersion: "7.102.10.4817", installs: 397},
+  "{e001c731-5e37-4538-a5cb-8168736a2360}": {minVersion: "0.9.9.152", installs: 396},
+  "{95E84BD3-3604-4AAC-B2CA-D9AC3E55B64B}": {minVersion: "2.0.0.78", installs: 393},
+  "_8lMembers_@free.filesharefanatic.com": {minVersion: "7.102.10.4171", installs: 389},
+  "clipconverter@clipconverter.cc": {minVersion: "1.5.2", installs: 387},
+  "_7jMembers_@download.gardeningenthusiast.com": {minVersion: "7.102.10.4260", installs: 383},
+  "antmark@ant.com": {minVersion: "1.1.14", installs: 383},
+  "_flMembers_@free.myformsfinder.com": {minVersion: "7.102.10.4784", installs: 381},
+  "{c36177c0-224a-11da-8cd6-0800200c9a91}": {minVersion: "3.9.85.1-signed.1-signed", installs: 375},
+  "@searchincognito": {minVersion: "0.1.0", installs: 375},
+  "{f13b157f-b174-47e7-a34d-4815ddfdfeb8}": {minVersion: "0.9.89.1-signed.1-signed", installs: 373},
+  "_5eMembers_@www.translationbuddy.com": {minVersion: "7.38.8.45962", installs: 372},
+  "{9c51bd27-6ed8-4000-a2bf-36cb95c0c947}": {minVersion: "11.0.1.1-signed.1-signed", installs: 370},
+  "clickclean@hotcleaner.com": {minVersion: "4.1.1-signed.1-signed", installs: 366},
+  "jid1-xKH0EoS44u1a2w@jetpack": {minVersion: "0.1.1-signed.1-signed", installs: 366},
+  "{c2056674-a37f-4b29-9300-2004759d74fe}": {minVersion: "2.0.0.1090", installs: 361},
+  "newtab-tv-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 359},
+  "ascsurfingprotectionnew@iobit.com": {minVersion: "2.1.3", installs: 355},
+  "FunTabSafe-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 353},
+  "d.lehr@chello.at": {minVersion: "1.2", installs: 350},
+  "anticontainer@downthemall.net": {minVersion: "1.5", installs: 348},
+  "{F8A55C97-3DB6-4961-A81D-0DE0080E53CB}": {minVersion: "1.0.10", installs: 347},
+  "@FormsApp": {minVersion: "0.2.0", installs: 346},
+  "multilinksplus@hugsmile.eu": {minVersion: "3.9.3", installs: 343},
+  "jid1-KWFaW5zc0EbtBQ@jetpack": {minVersion: "0.2.0", installs: 335},
+  "{e8f509f0-b677-11de-8a39-0800200c9a66}": {minVersion: "1.12.1-signed.1-let-fixed.1-signed", installs: 334},
+  "{37E4D8EA-8BDA-4831-8EA1-89053939A250}": {minVersion: "3.0.0.2.1-signed.1-signed", installs: 333},
+  "{c8d3bc80-0810-4d21-a2c2-be5f2b2832ac}": {minVersion: "0.98", installs: 332},
+  "{cb40da56-497a-4add-955d-3377cae4c33b}": {minVersion: "10.2.0.271", installs: 331},
+  "{5546F97E-11A5-46b0-9082-32AD74AAA920}": {minVersion: "0.76.1-signed.1-signed", installs: 325},
+  "_14Members_@www.totalrecipesearch.com": {minVersion: "7.38.8.45925", installs: 324},
+  "info@mp3it.eu": {minVersion: "1.4.1.1-signed.1-signed", installs: 324},
+  "firefox-autofill@googlegroups.com": {minVersion: "3.6.1-signed.1-signed", installs: 317},
+  "jid1-TQvJxTBYHA8qXg@jetpack": {minVersion: "0.4.1-signed.1-signed", installs: 315},
+  "{8f8fe09b-0bd3-4470-bc1b-8cad42b8203a}": {minVersion: "0.17.1-signed.1-signed", installs: 311},
+  "{D4DD63FA-01E4-46a7-B6B1-EDAB7D6AD389}": {minVersion: "0.9.10.1-signed.1-signed", installs: 311},
+  "{d7f46ca0-899d-11da-a72b-0800200c9a65}": {minVersion: "0.1.2.1-signed.1-signed", installs: 311},
+  "twoo@twoo.com": {minVersion: "1.6.0.1-signed", installs: 303},
+  "_29Members_@www.headlinealley.com": {minVersion: "7.38.8.56537", installs: 302},
+  "_e2Members_@free.coolpopulargames.com": {minVersion: "7.38.8.45873", installs: 300},
+  "TopTVTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 300},
+  "tmbepff@trendmicro.com": {minVersion: "9.2.0.1026", installs: 293},
+  "_2vMembers_@www.dailybibleguide.com": {minVersion: "7.38.8.52880", installs: 289},
+  "{54e46280-0211-11e3-b778-0800200c9a66}": {minVersion: "0.3", installs: 285},
+  "_49Members_@www.utilitychest.com": {minVersion: "7.38.8.45977", installs: 284},
+  "amcontextmenu@loucypher": {minVersion: "0.4.2.1-signed.1-signed", installs: 284},
+  "jid1-r1tDuNiNb4SEww@jetpack": {minVersion: "1.1.2673", installs: 283},
+  "_erMembers_@free.getvideoconvert.com": {minVersion: "7.102.10.5038", installs: 281},
+  "{b1df372d-8b32-4c7d-b6b4-9c5b78cf6fb1}": {minVersion: "0.87.1-signed.1-signed", installs: 281},
+  "jid1-cHKBMlArKdIVEg@jetpack": {minVersion: "1.24.1-signed.1-signed", installs: 281},
+  "@90B817C8-8A5C-413B-9DDD-B2C61ED6E79A": {minVersion: "1.09", installs: 278},
+  "smarterwiki@wikiatic.com": {minVersion: "5.2.1.1-signed.1-signed", installs: 278},
+  "whatsapppanel@alejandrobrizuela.com.ar": {minVersion: "1.1.1.1-signed.1-signed", installs: 277},
+  "lazarus@interclue.com": {minVersion: "2.3.1-signed.1-signed", installs: 275},
+  "{DEDA1132-B316-11DD-8BC1-4E5D56D89593}": {minVersion: "0.18", installs: 274},
+  "_h2Members_@free.calendarspark.com": {minVersion: "7.102.10.3641", installs: 273},
+  "@youtubedownloadere": {minVersion: "0.0.1", installs: 273},
+  "multirevenue@googlemail.com": {minVersion: "6.1.1", installs: 272},
+  "_d9Members_@www.everydaylookup.com": {minVersion: "7.102.10.4140", installs: 271},
+  "belgiumeid@eid.belgium.be": {minVersion: "1.0.21", installs: 271},
+  "{62DD0A97-FDD4-421b-94A5-D1A9434450C7}": {minVersion: "3.1", installs: 270},
+  "the-addon-bar@GeekInTraining-GiT": {minVersion: "3.2.9-compat-fixed-4", installs: 264},
+  "@phextension": {minVersion: "6.0.2", installs: 262},
+  "FunMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 262},
+  "{7f57cf46-4467-4c2d-adfa-0cba7c507e54}": {minVersion: "4.0.1", installs: 259},
+  "safefacebook@bkav": {minVersion: "1.0.4", installs: 255},
+  "content_blocker_6418E0D362104DADA084DC312DFA8ABC@kaspersky.com": {minVersion: "4.5.3.8", installs: 254},
+  "virtual_keyboard_294FF26A1D5B455495946778FDE7CEDB@kaspersky.com": {minVersion: "4.5.3.8", installs: 254},
+  "{B821BF60-5C2D-41EB-92DC-3E4CCD3A22E4}": {minVersion: "4.3.1.10", installs: 252},
+  "@E9438230-A7DF-4D1F-8F2D-CA1D0F0F7924": {minVersion: "1.08.8.66", installs: 252},
+  "jid1-6MGm94JnyY2VkA@jetpack": {minVersion: "2.1.8", installs: 250},
+  "{20a82645-c095-46ed-80e3-08825760534b}": {minVersion: "1.3.1.1-signed", installs: 246},
+  "{a192bf54-089f-4325-ac25-7eafcd17a342}": {minVersion: "3.2", installs: 246},
+  "e389d8c2-5554-4ba2-a36e-ac7a57093130@gmail.com": {minVersion: "1.44.275", installs: 244},
+  "yslow@yahoo-inc.com": {minVersion: "3.1.8.1-signed.1-signed", installs: 244},
+  "avg@safeguard": {minVersion: "19.6.0.592", installs: 243},
+  "@windscribeff": {minVersion: "0.1.43", installs: 242},
+  "jid1-PBNne26X1Kn6hQ@jetpack": {minVersion: "3.3.3", installs: 240},
+  "{53A03D43-5363-4669-8190-99061B2DEBA5}": {minVersion: "1.5.14", installs: 239},
+  "@offersolymp": {minVersion: "0.0.2", installs: 238},
+  "firefox@dotvpn.com": {minVersion: "1.0.2", installs: 238},
+  "{62760FD6-B943-48C9-AB09-F99C6FE96088}": {minVersion: "4.2.9", installs: 236},
+  "jid1-sNL73VCI4UB0Fw@jetpack": {minVersion: "2.1.4", installs: 236},
+  "low_quality_flash@pie2k.com": {minVersion: "0.2.1-signed.1-signed", installs: 236},
+  "jid1-l6VQSR2FeKnliQ@jetpack": {minVersion: "2.0.1-signed", installs: 235},
+  "_5zMembers_@www.couponxplorer.com": {minVersion: "7.102.10.3738", installs: 234},
+  "adonis.cuhk@gmail.com": {minVersion: "1.8.9.1-signed.1-signed", installs: 234},
+  "_e1Members_@free.actionclassicgames.com": {minVersion: "7.38.8.45834", installs: 232},
+  "{ea4637dc-e014-4c17-9c2c-879322d23268}": {minVersion: "2.1.1-signed.1-signed", installs: 229},
+  "{4DC70064-89E2-4a55-8FC6-E8CDEAE3618C}": {minVersion: "0.7.7.1-signed.1-signed", installs: 228},
+  "odyssey_crypto_control@odysseytec.com": {minVersion: "3.5", installs: 228},
+  "seostatus@rubyweb": {minVersion: "1.5.9.1-signed.1-signed", installs: 228},
+  "_apMembers_@free.puzzlegamesdaily.com": {minVersion: "7.102.10.4865", installs: 227},
+  "@safesearchincognito": {minVersion: "0.1.8", installs: 226},
+  "jid1-HfCj61J5q2gaGQ@jetpack": {minVersion: "1.0.3", installs: 224},
+  "@stopads": {minVersion: "0.0.4", installs: 224},
+  "dta3noaero@vano": {minVersion: "1.0.1", installs: 224},
+  "rainbow@colors.org": {minVersion: "1.6.1-signed.1-signed", installs: 223},
+  "{146f1820-2b0d-49ef-acbf-d85a6986e10c}": {minVersion: "0.1.9.3.1-signed.1-signed", installs: 222},
+  "{b2bfe60c-eef8-4e20-8334-c53afdc1ffdd}": {minVersion: "3.2", installs: 222},
+  "{b7870b41-bfb3-44cd-8cc2-e392e51b0874}": {minVersion: "3.8", installs: 222},
+  "printPages2Pdf@reinhold.ripper": {minVersion: "0.1.9.3.1-signed", installs: 221},
+  "YouTubetoALL@ALLPlayer.org": {minVersion: "0.8.5.1-signed.1-signed", installs: 221},
+  "{7a526449-3a92-426f-8ca4-47439918f2b1}": {minVersion: "3.2", installs: 219},
+  "jdwimqhayu@yahoo.com": {minVersion: "0.0.0.6", installs: 219},
+  "{54FBE89E-C878-46bb-A064-AB327EE26EBC}": {minVersion: "3.8", installs: 214},
+  "modernDownloadManager@teo.pl": {minVersion: "0.2.2", installs: 214},
+  "{eb8fff7e-1dce-4f3f-a51d-d9513ed6bab4}": {minVersion: "3.8", installs: 211},
+  "jid0-YQz0l1jthOIz179ehuitYAOdBEs@jetpack": {minVersion: "2.0.2", installs: 211},
+  "{7e80e173-7e63-464e-8252-fe170b15c15a}": {minVersion: "2.3", installs: 210},
+  "{35d6291e-1d4b-f9b4-c52f-77e6410d1326}": {minVersion: "4.11.1.0", installs: 209},
+  "{3c59c791-aeec-44bb-af60-ff112eea18e3}": {minVersion: "3.2", installs: 209},
+  "{90477448-b59c-48cd-98af-6a298cbc15d2}": {minVersion: "3.8", installs: 209},
+  "{24d26487-6274-48b1-b500-22f24884f971}": {minVersion: "2.3", installs: 208},
+  "{b7389dbc-6646-412f-bbd5-53168ee68a98}": {minVersion: "49", installs: 208},
+  "{22181a4d-af90-4ca3-a569-faed9118d6bc}": {minVersion: "11.0.0.1181", installs: 207},
+  "printpdf@pavlov.net": {minVersion: "0.76.1-signed.1-signed", installs: 207},
+  "@com.virtualjame.disableads": {minVersion: "0.1.0", installs: 206},
+  "{9AA46F4F-4DC7-4c06-97AF-6665170634FE}": {minVersion: "1.11.6.1-signed.1-signed", installs: 205},
+  "tinyjsdebugger@enigmail.net": {minVersion: "1.1.5", installs: 204},
+  "_foMembers_@free.flightsearchapp.com": {minVersion: "7.102.10.4176", installs: 202},
+  "jid1-rs90nxQtPi3Asg@jetpack": {minVersion: "1.8.1-signed.1-signed", installs: 201},
+  "vlcplaylist@helgatauscher.de": {minVersion: "0.8.1-signed.1-signed", installs: 201},
+  "jid1-G80Ec8LLEbK5fQ@jetpack": {minVersion: "1.3.8", installs: 200},
+  "_gpMembers_@free.mymapswizard.com": {minVersion: "7.102.10.4775", installs: 199},
+  "BestMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 199},
+  "info@convert2mp3.net": {minVersion: "2.5.1-signed.1-signed", installs: 199},
+  "partnerdefaults@mozilla.com": {minVersion: "1.0.1", installs: 199},
+  "qwantcomforfirefox@jetpack": {minVersion: "3.0.28", installs: 199},
+  "{65e41d20-f092-41b7-bb83-c6e8a9ab0f57}": {minVersion: "1.2.6", installs: 198},
+  "amznUWL2@amazon.com": {minVersion: "1.11", installs: 197},
+  "{1b80ae74-4912-44fc-9f27-30f9252a5ad7}": {minVersion: "2.3", installs: 197},
+  "{c9b4cd26-6f0e-4972-a9e0-8b77e811aa8f}": {minVersion: "2.3", installs: 197},
+  "shopcbtoolbar2@befrugal.com": {minVersion: "2013.3.23.1", installs: 197},
+  "trafficlight@bitdefender.com": {minVersion: "0.2.23.1-signed.1-signed", installs: 197},
+  "webrank-toolbar@probcomp.com": {minVersion: "4.4.1.1-signed.1-signed", installs: 197},
+  "_4lMembers_@www.bibletriviatime.com": {minVersion: "7.102.10.4330", installs: 196},
+  "xthunder@lshai.com": {minVersion: "1.3.4.1-signed.1-signed", installs: 196},
+  "extension@hidemyass.com": {minVersion: "1.3.2", installs: 195},
+  "jid1-MIAJd5BiK7V4Pw@jetpack": {minVersion: "0.9.1-signed.1-signed", installs: 195},
+  "{51aa69f8-8825-4def-916a-a766c5e3c0fd}": {minVersion: "3.8", installs: 194},
+  "{2bc72c53-9bde-4db2-8479-eda9a5e71f4e}": {minVersion: "3.2", installs: 193},
+  "{a95d8332-e4b4-6e7f-98ac-20b733364387}": {minVersion: "1.0.5", installs: 191},
+  "ocr@babylon.com": {minVersion: "1.1", installs: 191},
+  "{d3b9472c-f8b1-4a10-935b-1087bac8417f}": {minVersion: "3.8", installs: 189},
+  "windowpromo@dm73.net": {minVersion: "1.6", installs: 188},
+  "alldownloader@link64": {minVersion: "1.00.17.1-signed.1-signed", installs: 187},
+  "{3e0e7d2a-070f-4a47-b019-91fe5385ba79}": {minVersion: "3.6.5.2", installs: 185},
+  "jid1-vFmnfCkyf5VeSA@jetpack": {minVersion: "0.4.0", installs: 185},
+  "@greatdealz": {minVersion: "0.0.3", installs: 184},
+  "superstart@enjoyfreeware.org": {minVersion: "7.4.0.1-signed", installs: 183},
+  "{c2fc3c2b-a65a-453c-bf95-101fde56ed1d}": {minVersion: "2.3", installs: 182},
+  "{53152e75-fd90-472f-9d30-5cba3679eab9}": {minVersion: "48.3", installs: 180},
+  "jid0-raWjElI57dRa4jx9CCiYm5qZUQU@jetpack": {minVersion: "3.0.12.1.1-signed.1-signed", installs: 180},
+  "_ivMembers_@free.simplepictureedit.com": {minVersion: "7.102.10.14166", installs: 179},
+  "jid1-wKRSK9TpFpr9Hw@jetpack": {minVersion: "0.92", installs: 179},
+  "emailExtractor@penzil.com": {minVersion: "1.3.1-signed.1-signed", installs: 178},
+  "{60B7679C-BED9-11E5-998D-8526BB8E7F8B}": {minVersion: "6.3", installs: 177},
+  "@pdfit": {minVersion: "0.1.9", installs: 177},
+  "jid1-6AyZ1PQXsR9LgQ@jetpack": {minVersion: "0.2.1", installs: 177},
+  "_6oMembers_@free.heroicplay.com": {minVersion: "7.38.8.46626", installs: 175},
+  "{4BBDD651-70CF-4821-84F8-2B918CF89CA3}": {minVersion: "8.9.3.1", installs: 173},
+  "jid1-GeRCnsiDhZiTvA@jetpack": {minVersion: "1.0.3", installs: 172},
+  "jid0-zs24wecdcQo0Lp18D7QOV4WSZFo@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 171},
+  "{c50ca3c4-5656-43c2-a061-13e717f73fc8}": {minVersion: "5.0.1.48.1-signed.1-signed", installs: 170},
+  "selenium_ide_buttons@egarracingteam.com.ar": {minVersion: "1.2.0.1-signed.1-signed", installs: 170},
+  "WSVCU@Wondershare.com": {minVersion: "7.1.0", installs: 169},
+  "{4cc4a13b-94a6-7568-370d-5f9de54a9c7f}": {minVersion: "2.7.1-signed.1-signed", installs: 168},
+  "{aa84ce40-4253-a00a-8cd6-0800200f9a67}": {minVersion: "3.12.0", installs: 168},
+  "FasterFox_Lite@BigRedBrent": {minVersion: "3.9.9Lite.1-signed.1-signed", installs: 167},
+  "{6cc0f0f7-a6e2-4834-9682-24de2229b51e}": {minVersion: "23.6", installs: 166},
+  "{b749fc7c-e949-447f-926c-3f4eed6accfe}": {minVersion: "0.7.1.1.1-signed.1-signed", installs: 166},
+  "@mendeleyimporter": {minVersion: "1.6.8", installs: 166},
+  "ALone-live@ya.ru": {minVersion: "1.4.11", installs: 166},
+  "{4093c4de-454a-4329-8aff-c6b0b123c386}": {minVersion: "0.8.14.1-signed.1-signed", installs: 165},
+  "cookiemgr@jayapal.com": {minVersion: "5.12", installs: 164},
+  "touchenex@raon.co.kr": {minVersion: "1.0.1.11", installs: 163},
+  "{b0e1b4a6-2c6f-4e99-94f2-8e625d7ae255}": {minVersion: "3.5.0.1-signed.1-signed", installs: 162},
+  "isreaditlater@ideashower.com": {minVersion: "3.0.6.1-signed", installs: 161},
+  "safesearchplus@avira.com": {minVersion: "1.4.1.371", installs: 161},
+  "_e0Members_@www.downshotfree.com": {minVersion: "7.102.10.3833", installs: 159},
+  "LDSI_plashcor@gmail.com": {minVersion: "1.1.0.3", installs: 159},
+  "jid1-9ETkKdBARv7Iww@jetpack": {minVersion: "0.20.1-signed.1-signed", installs: 157},
+  "jid1-CGxMej0nDJTjwQ@jetpack": {minVersion: "1.0.1-signed.1-signed", installs: 157},
+  "{00f7ab9f-62f4-4145-b2f9-38d579d639f6}": {minVersion: "49", installs: 156},
+  "googledictionary@toptip.ca": {minVersion: "7.5", installs: 156},
+  "shopearn@prodege.com": {minVersion: "219", installs: 156},
+  "fvdmedia@gmail.com": {minVersion: "11.0.1", installs: 155},
+  "magicplayer_unlisted@acestream.org": {minVersion: "1.1.42", installs: 155},
+  "{0538E3E3-7E9B-4d49-8831-A227C80A7AD3}": {minVersion: "2.2.2.1-signed.1-let-fixed.1-signed", installs: 154},
+  "{73007fef-a6e0-47d3-b4e7-dfc116ed6f65}": {minVersion: "1.15.1-signed.1-signed", installs: 153},
+  "{cd617372-6743-4ee4-bac4-fbf60f35719e}": {minVersion: "2.0.1-signed.1-signed", installs: 152},
+  "TopSecurityTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 152},
+  "jid1-hDf2iQXGiUjzGQ@jetpack": {minVersion: "2.5.0", installs: 151},
+  "_dnMembers_@www.free.webmailworld.com": {minVersion: "7.102.10.5052", installs: 149},
+  "jid1-rrMTK7JqsxNOeQ@jetpack": {minVersion: "2.1.0", installs: 149},
+  "jid1-XgC5trUcILmXBw@jetpack": {minVersion: "2.0.3", installs: 149},
+  "online_banking_69A4E213815F42BD863D889007201D82@kaspersky.com": {minVersion: "4.5.3.8", installs: 148},
+  "jid1-AXn9cXcB4fD1QQ@jetpack": {minVersion: "0.7.4", installs: 148},
+  "feedly@devhd": {minVersion: "16.0.528.1-signed.1-signed", installs: 147},
+  "{6E727987-C8EA-44DA-8749-310C0FBE3C3E}": {minVersion: "2.0.0.11", installs: 146},
+  "{1082eb84-f0f2-11e5-8e18-9bb85ab7992e}": {minVersion: "1.07", installs: 146},
+  "{c151d79e-e61b-4a90-a887-5a46d38fba99}": {minVersion: "2.8.8", installs: 146},
+  "public.proartex@gmail.com": {minVersion: "1.1.3", installs: 145},
+  "jid1-8J7ayxTha4KqKQ@jetpack": {minVersion: "1.1.1-signed.1-signed", installs: 144},
+  "stealthyextension@gmail.com": {minVersion: "3.0.1.1-signed", installs: 144},
+  "_beMembers_@free.dailylocalguide.com": {minVersion: "7.38.9.7920", installs: 143},
+  "mytube@ashishmishra.in": {minVersion: "0.979.1-signed.1-signed", installs: 142},
+  "@A3592ADB-854A-443A-854E-EB92130D470D": {minVersion: "1.08.8.88", installs: 139},
+  "FunkyTVTabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 139},
+  "jid1-QpHD8URtZWJC2A@jetpack": {minVersion: "4.3.0", installs: 138},
+  "savedeo-video-downloader@fczbkk.com": {minVersion: "0.4.1.1-signed.1-signed", installs: 137},
+  "toolbar@shopathome.com": {minVersion: "8.20.3.1", installs: 137},
+  "_dyMembers_@www.dezipper.com": {minVersion: "7.102.10.3775", installs: 135},
+  "jid0-zXo3XFGyiDalgkeEO4UYJTUwo2I@jetpack": {minVersion: "1.0.0", installs: 134},
+  "{d57c9ff1-6389-48fc-b770-f78bd89b6e8a}": {minVersion: "1.46.1-signed.1-signed", installs: 133},
+  "@searchlock-fx": {minVersion: "1.1.6", installs: 133},
+  "dm@jetpack": {minVersion: "0.0.2", installs: 133},
+  "proxyselector@mozilla.org": {minVersion: "1.31.1-signed.1-signed", installs: 133},
+  "{065829BC-17B5-4C0B-9429-3173C361092E}": {minVersion: "1.0.8", installs: 132},
+  "{ada4b710-8346-4b82-8199-5de2b400a6ae}": {minVersion: "2.1.5.5.3", installs: 132},
+  "readable@evernote.com": {minVersion: "10.2.1.7.1-signed", installs: 131},
+  "{d48a39ba-8f80-4fce-8ee1-bc710561c55d}": {minVersion: "3.1.0.1-signed.1-signed", installs: 131},
+  "autorefresh@plugin": {minVersion: "1.0.2.1-signed.1-signed", installs: 130},
+  "SafeBrowseSearch-the-extension1@mozilla.com": {minVersion: "0.1.2", installs: 130},
+  "browsermodulecorp@browcorporation.org": {minVersion: "2.3", installs: 129},
+  "wisestamp@wisestamp.com": {minVersion: "4.14.20", installs: 127},
+  "_63Members_@www.aplusgamer.com": {minVersion: "7.38.8.45832", installs: 126},
+  "bestproxyswitcher@bestproxyswitcher.com": {minVersion: "3.4.6.1-signed.1-signed", installs: 126},
+  "jid1-AVgCeF1zoVzMjA@jetpack": {minVersion: "0.9.5.6", installs: 126},
+  "{ce7e73df-6a44-4028-8079-5927a588c948}": {minVersion: "1.1.4", installs: 125},
+  "{E71B541F-5E72-5555-A47C-E47863195841}": {minVersion: "3.0.3", installs: 125},
+  "{F5DDF39C-9293-4d5e-9AA8-E04E6DD5E9B4}": {minVersion: "1.6.3.1-signed.1-signed", installs: 125},
+  "@simplepopupblocker": {minVersion: "1.2.1", installs: 125},
+  "commonfix@mozillaonline.com": {minVersion: "0.13", installs: 125},
+  "searchme@mybrowserbar.com": {minVersion: "2.8", installs: 125},
+  "_4wMembers_@www.retrogamer.com": {minVersion: "7.38.8.46604", installs: 124},
+  "{71328583-3CA7-4809-B4BA-570A85818FBB}": {minVersion: "0.8.6.3.1-let-fixed", installs: 123},
+  "dmremote@westbyte.com": {minVersion: "1.9.3", installs: 123},
+  "@google-translate-menu": {minVersion: "1.0.1", installs: 122},
+  "_aaMembers_@free.eliteunzip.com": {minVersion: "7.39.8.50909", installs: 121},
+  "{8620c15f-30dc-4dba-a131-7c5d20cf4a29}": {minVersion: "3.9", installs: 121},
+  "{eb4b28c8-7f2d-4327-a00c-40de4299ba44}": {minVersion: "1.7", installs: 121},
+  "flashlight@stephennolan.com.au": {minVersion: "1.2.1-signed.1-signed", installs: 121},
+  "useragentoverrider@qixinglu.com": {minVersion: "0.4.1", installs: 121},
+  "{1B33E42F-EF14-4cd3-B6DC-174571C4349C}": {minVersion: "4.7", installs: 120},
+  "_dxMembers_@www.download-freemaps.com": {minVersion: "7.38.8.46371", installs: 120},
+  "{95ab36d4-fb6f-47b0-8b8d-e5f3bd547953}": {minVersion: "4.20.13.1-signed.1-signed", installs: 120},
+  "FirefoxAddon@similarWeb.com": {minVersion: "4.0.6", installs: 120},
+  "flashstopper@byo.co.il": {minVersion: "1.4.2", installs: 120},
+  "{15e67a59-bd3d-49ae-90dd-b3d3fd14c2ed}": {minVersion: "1.0.3.1-signed.1-signed", installs: 119},
+  "{c37bac34-849a-4d28-be41-549b2c76c64e}": {minVersion: "2.6", installs: 119},
+  "{03B08592-E5B4-45ff-A0BE-C1D975458688}": {minVersion: "1.1.1-signed.1-signed", installs: 118},
+  "newtabgoogle@graememcc.co.uk": {minVersion: "1.0.2.1-signed.1-signed", installs: 118},
+  "SocialNewtabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 118},
+  "@kikikokicicidada": {minVersion: "2.1.2", installs: 117},
+  "{9D6218B8-03C7-4b91-AA43-680B305DD35C}": {minVersion: "4.0.5", installs: 116},
+  "extension@one-tab.com": {minVersion: "1.17.0", installs: 116},
+  "{22119944-ED35-4ab1-910B-E619EA06A115}": {minVersion: "7.9.21.5", installs: 115},
+  "admin@hide-my-ip.org": {minVersion: "9.6.3", installs: 115},
+  "bdwteffv19@bitdefender.com": {minVersion: "2.2.1", installs: 115},
+  "exif_viewer@mozilla.doslash.org": {minVersion: "2.00.1-signed.1-signed", installs: 115},
+  "MyStartab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 115},
+  "coralietab@mozdev.org": {minVersion: "2.04.20110724.1-signed.1-signed", installs: 113},
+  "gaurangnshah@gmail.com": {minVersion: "1.3.2.1-signed.1-signed", installs: 113},
+  "ImagePicker@topolog.org": {minVersion: "1.9.4", installs: 113},
+  "{d49a148e-817e-4025-bee3-5d541376de3b}": {minVersion: "3.1.1-signed.1-signed", installs: 112},
+  "firebug@tools.sitepoint.com": {minVersion: "1.6.1-signed.1-signed", installs: 111},
+  "add-to-searchbox@maltekraus.de": {minVersion: "2.9", installs: 110},
+  "captiondownloader@hiephm.com": {minVersion: "2.3.1-signed.1-signed", installs: 110},
+  "jid1-LYopfl0r00ZV5k@jetpack": {minVersion: "1.0.1-signed.1-signed", installs: 110},
+  "{7CA9CF31-1C73-46CD-8377-85AB71EA771F}": {minVersion: "5.0.12", installs: 109},
+  "jid1-HdwPLukcGQeOSh@jetpack": {minVersion: "1.2.3", installs: 108},
+  "{0AA9101C-D3C1-4129-A9B7-D778C6A17F82}": {minVersion: "2.09.1-signed", installs: 107},
+  "CookiesIE@yahoo.com": {minVersion: "1.0.1-signed.1-signed", installs: 107},
+  "selenium-expert_selenium-ide@Samit.Badle": {minVersion: "0.25.1-signed.1-signed", installs: 107},
+  "{19EB90DC-A456-458b-8AAC-616D91AAFCE1}": {minVersion: "1.0.1-signed", installs: 105},
+  "application@itineraire.info": {minVersion: "4.5.0", installs: 105},
+  "rest-easy@quickmediasolutions.com": {minVersion: "0.3.1.1-signed", installs: 105},
+  "TopSocialHub-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 105},
+  "{7affbfae-c4e2-4915-8c0f-00fa3ec610a1}": {minVersion: "6.36.32", installs: 104},
+  "azhang@cloudacl.com": {minVersion: "0.19.6.9.1-signed.1-signed", installs: 104},
+  "FunCyberTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 104},
+  "SkipScreen@SkipScreen": {minVersion: "0.7.2.1-signed.1-signed", installs: 104},
+  "toolbar@seomoz.org": {minVersion: "3.1.18", installs: 104},
+  "{8b86149f-01fb-4842-9dd8-4d7eb02fd055}": {minVersion: "0.26.1-signed.1-signed", installs: 103},
+  "fbp@fbpurity.com": {minVersion: "9.3.2.1-signed", installs: 103},
+  "jid1-V8ev2melBDV3qQ@jetpack": {minVersion: "1.0.12.1-signed.1-signed", installs: 103},
+  "_fvMembers_@free.directionsace.com": {minVersion: "7.102.10.3790", installs: 102},
+  "{b6b1a201-b252-484f-b9fe-68efbb273fbd}": {minVersion: "1.10.1-signed.1-signed", installs: 102},
+  "flashfirebug@o-minds.com": {minVersion: "4.9.1", installs: 102},
+  "_ebMembers_@download.metrohotspot.com": {minVersion: "7.102.10.4735", installs: 101},
+  "{2e17e2b2-b8d4-4a67-8d7b-fafa6cc9d1d0}": {minVersion: "1.2.7.0.1-signed.1-signed", installs: 101},
+  "{ea61041c-1e22-4400-99a0-aea461e69d04}": {minVersion: "0.2.4.1-signed.1-signed", installs: 101},
+  "rapportive@rapportive.com": {minVersion: "1.4.0.1.1-signed.1-signed", installs: 101},
+  "_dvMembers_@www.testinetspeed.com": {minVersion: "7.38.8.45918", installs: 100},
+  "{9aad3da6-6c46-4ef0-9109-6df5eaaf597c}": {minVersion: "1.4.1.1-signed.1-signed", installs: 100},
+  "{c2b1f3ae-5cd5-49b7-8a0c-2c3bcbbbb294}": {minVersion: "1.1.1-signed.1-signed", installs: 100},
+  "jid0-w1UVmoLd6VGudaIERuRJCPQx1dQ@jetpack": {minVersion: "1.6.8.1-signed", installs: 100},
+  "_cxMembers_@www.autopcbackup.com": {minVersion: "7.102.10.3597", installs: 99},
+  "vpn@hide-my-ip.org": {minVersion: "10.6.2", installs: 99},
+  "{1a5dabbd-0e74-41da-b532-a364bb552cab}": {minVersion: "1.0.9.1-signed", installs: 98},
+  "FirePHPExtension-Build@firephp.org": {minVersion: "0.7.4.1-signed.1-signed", installs: 98},
+  "jid1-UXDr6c69BeyPVw@jetpack": {minVersion: "0.8.2", installs: 98},
+  "TopSafeTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 98},
+  "{3b56bcc7-54e5-44a2-9b44-66c3ef58c13e}": {minVersion: "0.9.7.4", installs: 97},
+  "autoreload@yz.com": {minVersion: "1.21", installs: 97},
+  "manish.p05@gmail.com": {minVersion: "12.9", installs: 97},
+  "videoresumer@jetpack": {minVersion: "1.1.4", installs: 97},
+  "@Radio": {minVersion: "0.2.0", installs: 96},
+  "_hfMembers_@free.everydaymanuals.com": {minVersion: "7.102.10.4142", installs: 96},
+  "jid0-jJRRRBMgoShUhb07IvnxTBAl29w@jetpack": {minVersion: "2.0.4", installs: 96},
+  "rikaichan-jpen@polarcloud.com": {minVersion: "2.01.160101", installs: 96},
+  "{7c6cdf7c-8ea8-4be7-ae5a-0b3effe14d66}": {minVersion: "49.1", installs: 95},
+  "{FDBAD97E-A258-4fe3-9CF6-60CF386C4422}": {minVersion: "2.0.1.6", installs: 95},
+  "intgcal@egarracingteam.com.ar": {minVersion: "1.5.1", installs: 95},
+  "MediaNewTab-the-extension1@mozilla.com": {minVersion: "0.1.6", installs: 95},
+  "{9EB34849-81D3-4841-939D-666D522B889A}": {minVersion: "2.4.0.157", installs: 94},
+  "{158d7cb3-7039-4a75-8e0b-3bd0a464edd2}": {minVersion: "2.7.1-signed.1-signed", installs: 94},
+  "jid1-ach2kaGSshPJCg@jetpack": {minVersion: "0.1.1-signed.1-signed", installs: 94},
+  "jid1-cwbvBTE216jjpg@jetpack": {minVersion: "2.1.0.1-signed.1-signed", installs: 94},
+  "{f36c6cd1-da73-491d-b290-8fc9115bfa55}": {minVersion: "3.0.9.1-signed.1-let-fixed.1-signed", installs: 93},
+  "dmpluginff@westbyte.com": {minVersion: "1.4.12", installs: 93},
+  "firefox@serptrends.com": {minVersion: "0.8.14", installs: 93},
+  "panel-plugin@effectivemeasure.com": {minVersion: "4.0.0", installs: 93},
+  "_evMembers_@www.free.bestbackground.com": {minVersion: "7.102.10.3607", installs: 92},
+  "canitbecheaper@trafficbroker.co.uk": {minVersion: "3.9.78", installs: 92},
+  "favorites_selenium-ide@Samit.Badle": {minVersion: "2.0.1-signed.1-signed", installs: 92},
+  "{5F590AA2-1221-4113-A6F4-A4BB62414FAC}": {minVersion: "0.45.8.20130519.3.1-signed.1-signed", installs: 90},
+  "{3e9bb2a7-62ca-4efa-a4e6-f6f6168a652d}": {minVersion: "2.7.7.1-signed.1-signed", installs: 90},
+  "{ab4b5718-3998-4a2c-91ae-18a7c2db513e}": {minVersion: "1.2.0.1-signed.1-signed", installs: 90},
+  "2020Player_WEB@2020Technologies.com": {minVersion: "5.0.94.0", installs: 90},
+  "translator@dontfollowme.net": {minVersion: "2.0.5", installs: 90},
+  "YouTubeAutoReplay@arikv.com": {minVersion: "3.3.1-signed.1-signed", installs: 90},
+  "{a949831f-d9c0-45ae-8c60-91c2a86fbfb6}": {minVersion: "0.2.1-signed.1-signed", installs: 89},
+  "@vpn-unlimited-secure-proxy": {minVersion: "4.4", installs: 89},
+  "jid1-JcGokIiQyjoBAQ@jetpack": {minVersion: "0.6.1-signed.1-signed", installs: 89},
+  "_73Members_@www.easyhomedecorating.com": {minVersion: "7.102.10.4129", installs: 88},
+  "{065ee92a-ad57-42a2-b6d5-466b6fd8e24d}": {minVersion: "0.11.6.1-signed.1-signed", installs: 88},
+  "{455D905A-D37C-4643-A9E2-F6FEFAA0424A}": {minVersion: "0.8.17.1-signed.1-signed", installs: 88},
+  "{7eb3f691-25b4-4a85-9038-9e57e2bcd537}": {minVersion: "0.4.4.1-signed.1-signed", installs: 88},
+  "FunSocialTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 88},
+  "Lucifox@lucidor.org": {minVersion: "0.9.13", installs: 88},
+  "YourMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 88},
+  "youtube-video-player@lejenome.me": {minVersion: "0.2.38.1-signed.1-signed", installs: 88},
+  "_hgMembers_@free.atozmanuals.com": {minVersion: "7.102.10.3604", installs: 87},
+  "abb-acer@amazon.com": {minVersion: "10.161.13.1002", installs: 87},
+  "gmail_panel@alejandrobrizuela.com.ar": {minVersion: "1.2.0", installs: 87},
+  "izer@camelcamelcamel.com": {minVersion: "2.8.2", installs: 87},
+  "tvnewtab-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 87},
+  "vlc_shortcut@kosan.kosan": {minVersion: "0.8.3.0", installs: 87},
+  "youtubeunblocker@unblocker.yt": {minVersion: "0.6.20", installs: 86},
+  "email@jetpack": {minVersion: "0.0.16", installs: 86},
+  "extensions@gismeteo.com": {minVersion: "5.1.0.2", installs: 86},
+  "idaremote@westbyte.com": {minVersion: "1.6.3", installs: 86},
+  "{725fc0a6-1f6b-4cf9-ae17-748d111dc16d}": {minVersion: "1.1.0", installs: 85},
+  "jid1-461B0PwxL3oTt1@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 85},
+  "webdavlauncher@benryan.com": {minVersion: "1.1.0", installs: 85},
+  "jid1-ZM3BerwS6FsQAg@jetpack": {minVersion: "0.4.1-signed", installs: 84},
+  "_fwMembers_@free.howtosuite.com": {minVersion: "7.102.10.4280", installs: 84},
+  "{023e9ca0-63f3-47b1-bcb2-9badf9d9ef28}": {minVersion: "4.4.3.1-signed.1-signed", installs: 84},
+  "{25A1388B-6B18-46c3-BEBA-A81915D0DE8F}": {minVersion: "1.7.8.5.1-signed.1-signed", installs: 84},
+  "{75493B06-1504-4976-9A55-B6FE240FF0BF}": {minVersion: "3.4.0.0", installs: 84},
+  "facepaste.firefox.addon@azabani.com": {minVersion: "2.91", installs: 84},
+  "jid1-cplLTTY501TB2Q@jetpack": {minVersion: "0.5.1", installs: 84},
+  "_d1Members_@free.mysocialshortcut.com": {minVersion: "7.102.10.4792", installs: 83},
+  "{761a54f1-8ccf-4112-9e48-dbf72adf6244}": {minVersion: "2.3.1-signed.1-signed", installs: 83},
+  "{BBB77B49-9FF4-4d5c-8FE2-92B1D6CD696C}": {minVersion: "2.0.0.1083", installs: 83},
+  "{a3a5c777-f583-4fef-9380-ab4add1bc2a2}": {minVersion: "2.1.4", installs: 82},
+  "{eb80b076-a444-444c-a590-5aee5d977d80}": {minVersion: "2.6.18", installs: 82},
+  "KVAllmytube@KeepVid.com": {minVersion: "4.10.0", installs: 82},
+  "lumerias-instagram@lumerias.com": {minVersion: "1.3", installs: 82},
+  "omnibar@ajitk.com": {minVersion: "0.7.28.20141004.1-signed.1-signed", installs: 81},
+  "@autofillanyforms-easytatkal": {minVersion: "7.51.0", installs: 81},
+  "@youtuberightclick": {minVersion: "0.0.3", installs: 81},
+  "autoproxy@autoproxy.org": {minVersion: "0.4b2.2013051811.1-signed.1-let-fixed.1-signed", installs: 80},
+  "{e33788ea-0bb9-4502-9c77-bdc551afc8ad}": {minVersion: "1.0.4", installs: 80},
+  "dmmm@westbyte.com": {minVersion: "1.3.4", installs: 80},
+  "easycopy@smokyink.com": {minVersion: "2.7.0", installs: 80},
+  "jid1-LelsJ0Oz0rt71A@jetpack": {minVersion: "2.0.0", installs: 80},
+  "_f7Members_@download.smsfrombrowser.com": {minVersion: "7.38.8.45917", installs: 79},
+  "{6614d11d-d21d-b211-ae23-815234e1ebb5}": {minVersion: "3.9.13", installs: 79},
+  "FunTvTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 79},
+  "{4204c864-50bf-467a-95b3-0912b7f15869}": {minVersion: "1.2.00.1-signed.1-signed", installs: 78},
+  "{987311C6-B504-4aa2-90BF-60CC49808D42}": {minVersion: "3.1-signed.1-signed", installs: 78},
+  "uploader@adblockfilters.mozdev.org": {minVersion: "2.1.1-signed.1-let-fixed.1-signed", installs: 77},
+  "PageRank@addonfactory.in": {minVersion: "2.0.1-signed.1-signed", installs: 77},
+  "restartbutton@strk.jp": {minVersion: "0.1.5.1-signed.1-signed", installs: 77},
+  "text2voice@vik.josh": {minVersion: "1.15", installs: 77},
+  "_dpMembers_@free.findyourmaps.com": {minVersion: "7.102.10.4185", installs: 76},
+  "53ffxtbr@www.dailyfitnesscenter.com": {minVersion: "7.36.8.15623", installs: 76},
+  "gary@builtwith.com": {minVersion: "1.9.6.1-signed.1-signed", installs: 76},
+  "idamm@westbyte.com": {minVersion: "1.3.2", installs: 76},
+  "jid1-3gu11JeYBiIuJA@jetpack": {minVersion: "3.1.1", installs: 76},
+  "jid1-zV8eHYwTDNUtwQ@jetpack": {minVersion: "1.0.4", installs: 76},
+  "nst@neiron.ru": {minVersion: "7.3.0.2", installs: 76},
+  "service@touchpdf.com": {minVersion: "1.15.1-signed.1-signed", installs: 76},
+  "{02450954-cdd9-410f-b1da-db804e18c671}": {minVersion: "0.96.3.1-signed.1-signed", installs: 75},
+  "{4176DFF4-4698-11DE-BEEB-45DA55D89593}": {minVersion: "0.8.50.1-signed.1-signed", installs: 75},
+  "{DAD0F81A-CF67-4eed-98D6-26F6E47274CA}": {minVersion: "1.8.1-signed.1-signed", installs: 75},
+  "dealxplorermysites770@yahoo.com": {minVersion: "0.0.0.1", installs: 75},
+  "firefox@online-convert.com": {minVersion: "1.4.1-signed.1-signed", installs: 75},
+  "jid1-zmgYgiQPXJtjNA@jetpack": {minVersion: "1.23", installs: 75},
+  "_evMembers_@www.bestbackground.com": {minVersion: "7.38.9.7654", installs: 74},
+  "dmbarff@westbyte.com": {minVersion: "1.5.11", installs: 74},
+  "inf@youtube-mp3.video": {minVersion: "0.1", installs: 74},
+  "jid1-e7w0SHT82Gv9qA@jetpack": {minVersion: "1.2", installs: 74},
+  "NewTabTVCool-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 74},
+  "{E173B749-DB5B-4fd2-BA0E-94ECEA0CA55B}": {minVersion: "7.4.1-signed", installs: 73},
+  "{9BAE5926-8513-417d-8E47-774955A7C60D}": {minVersion: "1.1.1d.1-signed.1-signed", installs: 73},
+  "{3cc6c6ba-654c-417e-a8af-6997ac388ae1}": {minVersion: "49", installs: 72},
+  "{daf44bf7-a45e-4450-979c-91cf07434c3d}": {minVersion: "2.0.5", installs: 72},
+  "{dbac9680-d559-4cd4-9765-059879e8c467}": {minVersion: "5.0.5", installs: 72},
+  "application@recettes.net": {minVersion: "4.5.0", installs: 72},
+  "idapluginff@westbyte.com": {minVersion: "1.5.9", installs: 71},
+  "imgflashblocker@shimon.chohen": {minVersion: "0.7.1-signed.1-signed", installs: 71},
+  "inspector@mozilla.org": {minVersion: "2.0.16.1-signed", installs: 71},
+  "jid1-ReWlW1efOwaQJQ@jetpack": {minVersion: "1.1.2", installs: 71},
+  "youtubedownloader@trafficterminal.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 71},
+  "FavIconReloader@mozilla.org": {minVersion: "0.8.1-signed", installs: 70},
+  "_2bMembers_@www.bettercareersearch.com": {minVersion: "7.38.8.45828", installs: 70},
+  "{5e594888-3e8e-47da-b2c6-b0b545112f84}": {minVersion: "1.3.18", installs: 70},
+  "@greatdealzu": {minVersion: "0.0.3", installs: 70},
+  "86ffxtbr@download.yourvideochat.com": {minVersion: "7.36.8.15938", installs: 70},
+  "google@hitachi.com": {minVersion: "0.3.1-signed.1-signed", installs: 70},
+  "{6e84150a-d526-41f1-a480-a67d3fed910d}": {minVersion: "1.5.6.1-signed.1-signed", installs: 69},
+  "firepicker@thedarkone": {minVersion: "1.4.3.1-signed.1-signed", installs: 69},
+  "jid0-AocRXUCRsLTCYvn6bgJERnwfuqw@jetpack": {minVersion: "2.8.3.1-signed.1-signed", installs: 69},
+  "nortonsecurity@symantec.com": {minVersion: "7.2.0f90", installs: 69},
+  "{ef4e370e-d9f0-4e00-b93e-a4f274cfdd5a}": {minVersion: "1.4.10.1-signed", installs: 68},
+  "{d4e0dc9c-c356-438e-afbe-dca439f4399d}": {minVersion: "49.1", installs: 68},
+  "{E6C93316-271E-4b3d-8D7E-FE11B4350AEB}": {minVersion: "2.1.25.1-signed.1-signed", installs: 68},
+  "{fa8476cf-a98c-4e08-99b4-65a69cb4b7d4}": {minVersion: "1.7.6.1", installs: 68},
+  "simplesiteblocker@example.com": {minVersion: "1.1.1-signed.1-signed", installs: 68},
+  "_fpMembers_@free.passwordlogic.com": {minVersion: "7.102.10.4853", installs: 67},
+  "{6e764c17-863a-450f-bdd0-6772bd5aaa18}": {minVersion: "1.0.3.1-signed.1-signed", installs: 67},
+  "adbeaver@adbeaver.org": {minVersion: "0.7.2.9", installs: 67},
+  "application2@allo-pages.fr": {minVersion: "4.5.0", installs: 67},
+  "arf3@getcartt.com": {minVersion: "1.2.3", installs: 67},
+  "clearcache@michel.de.almeida": {minVersion: "2.0.1.1-signed.1-signed", installs: 67},
+  "fbmessengerpanel@alejandrobrizuela.com.ar": {minVersion: "1.0.3.1-signed.1-signed", installs: 67},
+  "tilt@mozilla.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 67},
+  "toolbar_AVIRA-V7@apn.ask.com": {minVersion: "127.25", installs: 67},
+  "{524B8EF8-C312-11DB-8039-536F56D89593}": {minVersion: "4.91.0.0", installs: 66},
+  "{9d1f059c-cada-4111-9696-41a62d64e3ba}": {minVersion: "0.17.0.1", installs: 66},
+  "{B068AC18-0121-4e67-9A7E-6386F93F4F7A}": {minVersion: "2.4", installs: 66},
+  "@lottadealsun": {minVersion: "0.0.1", installs: 66},
+  "@thebestyoutubedownloader": {minVersion: "1.0.0.7", installs: 66},
+  "TopSocialTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 66},
+  "{11483926-db67-4190-91b1-ef20fcec5f33}": {minVersion: "0.4.9.1", installs: 65},
+  "{8AA36F4F-6DC7-4c06-77AF-5035170634FE}": {minVersion: "2016.9.16", installs: 65},
+  "dam@tensons.com": {minVersion: "5.0.7", installs: 65},
+  "jid1-D7momAzRw417Ag@jetpack": {minVersion: "4.5.13", installs: 65},
+  "support@videoadd.ru": {minVersion: "2.8.1.1-signed.1-signed", installs: 65},
+  "{95322c08-05ff-4f3c-85fd-8ceb821988dd}": {minVersion: "49", installs: 64},
+  "AllMyTube@Wondershare.com": {minVersion: "4.9.1", installs: 64},
+  "azan-times@hamid.net": {minVersion: "1.2.3.1-signed.1-signed", installs: 64},
+  "check-compatibility@dactyl.googlecode.com": {minVersion: "1.3.1-signed.1-signed", installs: 64},
+  "ifamebook@stormvision.it": {minVersion: "4.03.1-signed", installs: 64},
+  "jid1-vRJA7N8VwBoiXw@jetpack": {minVersion: "1.1.1.1-signed", installs: 64},
+  "{04426594-bce6-4705-b811-bcdba2fd9c7b}": {minVersion: "1.7.1-signed.1-signed", installs: 63},
+  "{f3f219f9-cbce-467e-b8fe-6e076d29665c}": {minVersion: "50", installs: 63},
+  "fireforce@scrt.ch": {minVersion: "2.2.1-signed.1-signed", installs: 63},
+  "FunkyMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 63},
+  "TopTabTV-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 63},
+  "{018f3160-1a6f-4650-84fd-aad8c13609c8}": {minVersion: "0.1.1-signed.1-signed", installs: 62},
+  "{2e710e6b-5e9d-44ba-8f4e-09a040978b49}": {minVersion: "1.7", installs: 62},
+  "{c1970c0d-dbe6-4d91-804f-c9c0de643a57}": {minVersion: "1.3.2.13.1-signed.1-signed", installs: 62},
+  "{c9b4529a-eeba-4e48-976e-f3d3f9026e04}": {minVersion: "1.1.1-signed.1-signed", installs: 62},
+  "{df4e4df5-5cb7-46b0-9aef-6c784c3249f8}": {minVersion: "1.3.0.1-signed.1-signed", installs: 62},
+  "@stremio": {minVersion: "1.0.2", installs: 62},
+  "application@les-pages.com": {minVersion: "4.4.0", installs: 62},
+  "ffvkontaktemusic@chupakabr.ru": {minVersion: "2.2.1-signed.1-signed", installs: 62},
+  "firefinder@robertnyman.com": {minVersion: "1.4.1-signed.1-signed", installs: 62},
+  "formhistory@yahoo.com": {minVersion: "1.4.0.6", installs: 62},
+  "fxclickonce@rushyo.com": {minVersion: "0.1.1-signed.1-signed", installs: 62},
+  "gmail@borsosfisoft.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 62},
+  "HighlightedTextToFile@bobbyrne01.org": {minVersion: "2.7.1", installs: 62},
+  "jid1-n85lxPv1NAWVTQ@jetpack": {minVersion: "0.96.1.1-signed", installs: 62},
+  "ramback@pavlov.net": {minVersion: "1.0.1-signed.1-signed", installs: 62},
+  "VacuumPlacesImproved@lultimouomo-gmail.com": {minVersion: "1.2.1-signed.1-signed", installs: 62},
+  "@News": {minVersion: "0.2.0", installs: 61},
+  "{45d8ff86-d909-11db-9705-005056c00008}": {minVersion: "1.3.4.8", installs: 61},
+  "{686fc9c5-c339-43db-b93a-5181a217f9a6}": {minVersion: "1.11", installs: 61},
+  "{ea2b95c2-9be8-48ed-bdd1-5fcd2ad0ff99}": {minVersion: "0.3.8.1.1-signed.1-signed", installs: 61},
+  "@chomikuj": {minVersion: "1.2.0", installs: 61},
+  "avg@wtu3": {minVersion: "3.7.0.0", installs: 61},
+  "jid1-f7dnBeTj8ElpWQ@jetpack": {minVersion: "1.34.1-signed.1-signed", installs: 61},
+  "jid1-OY8Xu5BsKZQa6A@jetpack": {minVersion: "2.0.21", installs: 61},
+  "jid1-u9RbFp9JcoEGGw@jetpack": {minVersion: "1.2.2.1-signed.1-signed", installs: 61},
+  "plugin@okta.com": {minVersion: "5.8.0", installs: 61},
+  "showpassword@pratikpoddar": {minVersion: "1.7.1-signed.1-signed", installs: 61},
+  "IGF.F3@igufei.com": {minVersion: "3.2.11", installs: 60},
+  "{12b6fdcd-4423-4276-82a3-73fdbff5f7e4}": {minVersion: "50", installs: 60},
+  "{8F6A6FD9-0619-459f-B9D0-81DE065D4E21}": {minVersion: "1.13", installs: 60},
+  "jid1-mW7iuA66Ny8Ziw@jetpack": {minVersion: "0.9.1-signed.1-signed", installs: 60},
+  "nishan.naseer.googimagesearch@gmail.com": {minVersion: "0.5.1-signed.1-signed", installs: 60},
+  "quicksearch@yandex.ru": {minVersion: "1.0.13", installs: 60},
+  "{902D2C4A-457A-4EF9-AD43-7014562929FF}": {minVersion: "0.6.4", installs: 59},
+  "@yset": {minVersion: "0.0.10", installs: 59},
+  "csscoverage@spaghetticoder.org": {minVersion: "0.3.4.1-signed.1-signed", installs: 59},
+  "dgnria2@nuance.com": {minVersion: "15.00.000.058", installs: 59},
+  "firequery@binaryage.com": {minVersion: "2.0.4", installs: 59},
+  "IBM-cck@firefox-extensions.ibm.com": {minVersion: "2.3.0", installs: 59},
+  "trackmenot@mrl.nyu.edu": {minVersion: "0.9.2", installs: 59},
+  "_chMembers_@free.discoverancestry.com": {minVersion: "7.102.10.3818", installs: 58},
+  "{338e0b96-2285-4424-b4c8-e25560750fa3}": {minVersion: "3.1-signed.1-signed", installs: 58},
+  "{8b5bea8c-6194-4c7c-a440-d5ca181480c3}": {minVersion: "1.500.000.11", installs: 58},
+  "{e30e9060-21d5-11e3-8224-0800200c9a66}": {minVersion: "1.2.12", installs: 58},
+  "LDshowpicture_plashcor@gmail.com": {minVersion: "3.2", installs: 58},
+  "open.about.permissions@jasnapaka.com": {minVersion: "1.2.1-signed.1-signed", installs: 58},
+  "sqlime@security.compass": {minVersion: "0.4.7.1-signed.1-signed", installs: 58},
+  "@jetpack-easy-turism2": {minVersion: "7.1.0", installs: 57},
+  "check4change-owner@mozdev.org": {minVersion: "1.9.8.1", installs: 57},
+  "jid1-SDFC9fEAZRW7ab@jetpack": {minVersion: "0.1.3.1-signed.1-signed", installs: 57},
+  "linkgopher@oooninja.com": {minVersion: "1.3.3.1-signed.1-signed", installs: 57},
+  "pixelperfectplugin@openhouseconcepts.com": {minVersion: "2.0.14", installs: 57},
+  "YoutubeDownloader@huangho.net76.net": {minVersion: "1.6.5.1-signed.1-signed", installs: 57},
+  "lwthemes-manager@loucypher": {minVersion: "0.2.1-signed.1-let-fixed.1-signed", installs: 56},
+  "_eiMembers_@www.100sofrecipes.com": {minVersion: "7.102.10.3580", installs: 56},
+  "{068c594c-1a69-4f51-888d-1e231eac59a3}": {minVersion: "1", installs: 56},
+  "{139C4B80-60ED-11E4-80EC-84041E5D46B0}": {minVersion: "1.3", installs: 56},
+  "{4c7097f7-08f2-4ef2-9b9f-f95fa4cbb064}": {minVersion: "1.1", installs: 56},
+  "{776f38cb-6255-4b92-b5cf-e5c71ff2b688}": {minVersion: "1.6", installs: 56},
+  "{79c50f9a-2ffe-4ee0-8a37-fae4f5dacd4f}": {minVersion: "5.1.3", installs: 56},
+  "{8BCA0E8A-E57B-425b-A05B-CD3868EB577E}": {minVersion: "1.4.1-signed.1-signed", installs: 56},
+  "easycopypaste@everhelper.me": {minVersion: "1.1.0.1-signed.1-signed", installs: 56},
+  "NoiaFoxoption@davidvincent.tld": {minVersion: "3.0.2.1-signed", installs: 56},
+  "r2d2b2g@mozilla.org": {minVersion: "4.0.4.1-signed", installs: 56},
+  "TFToolbarX@torrent-finder": {minVersion: "1.3.1.1-signed.1-signed", installs: 56},
+  "{E4091D66-127C-11DB-903A-DE80D2EFDFE8}": {minVersion: "1.6.5.5.1-signed.1-signed", installs: 55},
+  "downintab@max.max": {minVersion: "1.00.1-signed.1-signed", installs: 55},
+  "flv2mp3@hotger.com": {minVersion: "2.3.2-signed", installs: 55},
+  "ISVCU@iSkysoft.com": {minVersion: "5.1.0", installs: 55},
+  "jid1-n5ARdBzHkUEdAA@jetpack": {minVersion: "3.8.7", installs: 55},
+  "rpnetdownloadhelper@gmail.com": {minVersion: "3.0.1-signed.1-signed", installs: 55},
+  "shpassword@shpassword.fr": {minVersion: "0.3.1-signed.1-signed", installs: 55},
+  "snt@simplenewtab.com": {minVersion: "1.3", installs: 55},
+  "admin@djamol.com": {minVersion: "4.31.1-signed.1-signed", installs: 54},
+  "{22870005-adef-4c9d-ae36-d0e1f2f27e5a}": {minVersion: "0.4.0.9.1.1-signed.1-signed", installs: 54},
+  "{DBBB3167-6E81-400f-BBFD-BD8921726F52}": {minVersion: "7125.2016.0115.2213", installs: 54},
+  "{e4f94d1e-2f53-401e-8885-681602c0ddd8}": {minVersion: "1.0.1-signed.1-signed", installs: 54},
+  "{FBF6D7FB-F305-4445-BB3D-FEF66579A033}": {minVersion: "6", installs: 54},
+  "5aa55fd5-6e61-4896-b186-fdc6f298ec92@mozilla": {minVersion: "0.1.2.1-signed", installs: 54},
+  "fireml@sirma.bg": {minVersion: "1.1.11.1-signed.1-signed", installs: 54},
+  "info@priceblink.com": {minVersion: "4.8", installs: 54},
+  "jid0-f82gosWvE8oeGQt6WDCGRF1Dy7Q@jetpack": {minVersion: "1.0.003", installs: 54},
+  "jid0-hyjN250ZzTOOX3evFwwAQBxE4ik@jetpack": {minVersion: "6.0.1-signed.1-signed", installs: 54},
+  "restart@restart.org": {minVersion: "0.5.1-signed.1-signed", installs: 54},
+  "webmaster@keep-tube.com": {minVersion: "1.2.1-signed.1-signed", installs: 54},
+  "eliteproxyswitcher@my-proxy.com": {minVersion: "1.2.0.2.1-signed.1-signed", installs: 53},
+  "foxfilter@inspiredeffect.net": {minVersion: "7.7.1-signed.1-signed", installs: 53},
+  "searchprivacy@searchprivacy.co": {minVersion: "1.15", installs: 53},
+  "SignPlugin@pekao.pl": {minVersion: "1.4.0.73", installs: 53},
+  "{15fe27f3-e5ab-2d59-4c5c-dadc7945bdbd}": {minVersion: "2.1.1.1-signed.1-signed", installs: 52},
+  "ipfuck@p4ul.info": {minVersion: "1.2.1.1-signed.1-signed", installs: 52},
+  "jyboy.yy@gmail.com": {minVersion: "1.0.4.1-signed.1-signed", installs: 52},
+  "MySafeTabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 52},
+  "saiful.neo@gmail.com": {minVersion: "3.0.1-signed.1-signed", installs: 52},
+  "sendtokindle@amazon.com": {minVersion: "1.0.2.76", installs: 52},
+  "smile1Button@amazon.com": {minVersion: "1.0.1-signed.1-signed", installs: 52},
+  "whodeletedme@deleted.io": {minVersion: "0.3.3", installs: 52},
+  "{C0CB8BA3-6C1B-47e8-A6AB-1FAB889562D9}": {minVersion: "0.7.6", installs: 51},
+  "@irctctatkal": {minVersion: "2.0.0", installs: 51},
+  "antgroup@antdownloadmanager.com": {minVersion: "0.1.7", installs: 51},
+  "downloadplan@firefoxmania.uci.cu": {minVersion: "1.3.1-signed.1-signed", installs: 51},
+  "jid1-AoXeeOB4j7kFdA@jetpack": {minVersion: "8.1", installs: 51},
+  "memoryrestart@teamextension.com": {minVersion: "1.18.1-signed.1-signed", installs: 51},
+  "multifox-toolbar-button@rbaldwin": {minVersion: "4.28.1-signed.1-signed", installs: 51},
+  "soaclient@santoso": {minVersion: "0.2.1-signed.1-signed", installs: 51},
+  "speeddns@gmail.com": {minVersion: "0.2.1-signed.1-signed", installs: 51},
+  "windowandtablimiter@weintraut.net": {minVersion: "4.28.1-signed.1-signed", installs: 51},
+  "@Recipes": {minVersion: "0.2.0", installs: 50},
+  "{e6a9a96e-4a08-4719-b9bd-0e91c35aaabc}": {minVersion: "1.3.1.1-signed.1-signed", installs: 50},
+  "autopager@mozilla.org": {minVersion: "0.8.0.10.1-signed.1-signed", installs: 50},
+  "btpersonas@brandthunder.com": {minVersion: "2.0.4.7", installs: 50},
+  "gdrivepanel@alejandrobrizuela.com.ar": {minVersion: "1.0.2.1-signed.1-signed", installs: 50},
+  "jid1-m3kqTBs1zKXXaA@jetpack": {minVersion: "0.2.6.1-signed.1-signed", installs: 50},
+  "qqmail_plugin_for_firefox@tencent.com": {minVersion: "1.0.0.22", installs: 50},
+  "savefileto@mozdev.org": {minVersion: "2.5.5", installs: 50},
+  "seodoctor@prelovac.com": {minVersion: "1.6.5.1-signed.1-signed", installs: 50},
+  "support@todoist.com": {minVersion: "4.0.5", installs: 50},
+  "toolbar_TeoMediaTB@apn.ask.com": {minVersion: "135.3", installs: 50},
+  "txftn@tencent.com": {minVersion: "1.0.0.7", installs: 50},
+};
+
+// ================== END OF LIST FOR 51 ======================
+
+// We use these named policies to correlate the telemetry
+// data with them, in order to understand how each set
+// is behaving in the wild.
+const RolloutPolicy = {
+  // Used during 48 Beta cycle
+  "2a": { addons: set2, webextensions: true },
+  "2b": { addons: set2, webextensions: false },
+
+  // Set agreed for Release 49
+  "49a": { addons: set49Release, webextensions: true },
+  "49b": { addons: set49Release, webextensions: false },
+
+  // Smaller set that can be used for Release 49
+  "49limiteda": { addons: set49PaneOnly, webextensions: true },
+  "49limitedb": { addons: set49PaneOnly, webextensions: false },
+
+  // Beta testing on 50
+  "50allmpc": { addons: [], webextensions: true, mpc: true },
+
+  // Beta testing on 51
+  "51alladdons": { addons: [], webextensions: true, alladdons: true },
+
+  // 51 release
+  "51set1": { addonsv2: set51Release, installs:   50, webextensions: true, mpc: true },
+  "51set2": { addonsv2: set51Release, installs:  100, webextensions: true, mpc: true },
+  "51set3": { addonsv2: set51Release, installs:  300, webextensions: true, mpc: true },
+  "51set4": { addonsv2: set51Release, installs: 1000, webextensions: true, mpc: true },
+
+  // ESR
+  "esrA": { addons: [], mpc: true, webextensions: true },
+  "esrB": { addons: [], mpc: true, webextensions: false },
+  "esrC": { addons: [], mpc: false, webextensions: true },
+
+  "xpcshell-test": { addons: [ADDONS.test1, ADDONS.test2], webextensions: false },
+};
+
+Object.defineProperty(this, "isAddonPartOfE10SRollout", {
+  configurable: false,
+  enumerable: false,
+  writable: false,
+  value: function isAddonPartOfE10SRollout(aAddon) {
+    let blocklist = Preferences.get(PREF_E10S_ADDON_BLOCKLIST, "");
+    let policyId = Preferences.get(PREF_E10S_ADDON_POLICY, "");
+
+    if (!policyId || !RolloutPolicy.hasOwnProperty(policyId)) {
+      return false;
+    }
+
+    if (blocklist && blocklist.indexOf(aAddon.id) > -1) {
+      return false;
+    }
+
+    let policy = RolloutPolicy[policyId];
+
+    if (aAddon.mpcOptedOut == true) {
+      return false;
+    }
+
+    if (policy.alladdons) {
+      return true;
+    }
+
+    if (policy.webextensions && aAddon.type == "webextension") {
+      return true;
+    }
+
+    if (policy.mpc && aAddon.multiprocessCompatible) {
+      return true;
+    }
+
+    if (policy.addonsv2) {
+      if (aAddon.id in policy.addonsv2) {
+        let rolloutAddon = policy.addonsv2[aAddon.id];
+
+        if (rolloutAddon.installs >= policy.installs &&
+            Services.vc.compare(aAddon.version, rolloutAddon.minVersion) >= 0) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    for (let rolloutAddon of policy.addons) {
+      if (aAddon.id == rolloutAddon.id &&
+          Services.vc.compare(aAddon.version, rolloutAddon.minVersion) >= 0) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+});
diff --git a/toolkit/mozapps/webextensions/internal/GMPProvider.jsm b/toolkit/mozapps/webextensions/internal/GMPProvider.jsm
new file mode 100644
index 000000000..9bb34a7af
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/GMPProvider.jsm
@@ -0,0 +1,699 @@
+/* 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 Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = [];
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/AddonManager.jsm");
+/* globals AddonManagerPrivate*/
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Preferences.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+/* globals OS*/
+Cu.import("resource://gre/modules/Log.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/GMPUtils.jsm");
+/* globals EME_ADOBE_ID, GMP_PLUGIN_IDS, GMPPrefs, GMPUtils, OPEN_H264_ID, WIDEVINE_ID */
+Cu.import("resource://gre/modules/AppConstants.jsm");
+Cu.import("resource://gre/modules/UpdateUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(
+  this, "GMPInstallManager", "resource://gre/modules/GMPInstallManager.jsm");
+XPCOMUtils.defineLazyModuleGetter(
+  this, "setTimeout", "resource://gre/modules/Timer.jsm");
+
+const URI_EXTENSION_STRINGS  = "chrome://mozapps/locale/extensions/extensions.properties";
+const STRING_TYPE_NAME       = "type.%ID%.name";
+
+const SEC_IN_A_DAY           = 24 * 60 * 60;
+// How long to wait after a user enabled EME before attempting to download CDMs.
+const GMP_CHECK_DELAY        = 10 * 1000; // milliseconds
+
+const NS_GRE_DIR             = "GreD";
+const CLEARKEY_PLUGIN_ID     = "gmp-clearkey";
+const CLEARKEY_VERSION       = "0.1";
+
+const GMP_LICENSE_INFO       = "gmp_license_info";
+const GMP_PRIVACY_INFO       = "gmp_privacy_info";
+const GMP_LEARN_MORE         = "learn_more_label";
+
+const GMP_PLUGINS = [
+  {
+    id:              OPEN_H264_ID,
+    name:            "openH264_name",
+    description:     "openH264_description2",
+    // The following licenseURL is part of an awful hack to include the OpenH264
+    // license without having bug 624602 fixed yet, and intentionally ignores
+    // localisation.
+    licenseURL:      "chrome://mozapps/content/extensions/OpenH264-license.txt",
+    homepageURL:     "http://www.openh264.org/",
+    optionsURL:      "chrome://mozapps/content/extensions/gmpPrefs.xul",
+  },
+  {
+    id:              EME_ADOBE_ID,
+    name:            "eme-adobe_name",
+    description:     "eme-adobe_description",
+    // The following learnMoreURL is another hack to be able to support a SUMO page for this
+    // feature.
+    get learnMoreURL() {
+      return Services.urlFormatter.formatURLPref("app.support.baseURL") + "drm-content";
+    },
+    licenseURL:      "http://help.adobe.com/en_US/primetime/drm/HTML5_CDM_EULA/index.html",
+    homepageURL:     "http://help.adobe.com/en_US/primetime/drm/HTML5_CDM",
+    optionsURL:      "chrome://mozapps/content/extensions/gmpPrefs.xul",
+    isEME:           true,
+  },
+  {
+    id:              WIDEVINE_ID,
+    name:            "widevine_description",
+    // Describe the purpose of both CDMs in the same way.
+    description:     "eme-adobe_description",
+    licenseURL:      "https://www.google.com/policies/privacy/",
+    homepageURL:     "https://www.widevine.com/",
+    optionsURL:      "chrome://mozapps/content/extensions/gmpPrefs.xul",
+    isEME:           true
+  }];
+XPCOMUtils.defineConstant(this, "GMP_PLUGINS", GMP_PLUGINS);
+
+XPCOMUtils.defineLazyGetter(this, "pluginsBundle",
+  () => Services.strings.createBundle("chrome://global/locale/plugins.properties"));
+XPCOMUtils.defineLazyGetter(this, "gmpService",
+  () => Cc["@mozilla.org/gecko-media-plugin-service;1"].getService(Ci.mozIGeckoMediaPluginChromeService));
+
+var messageManager = Cc["@mozilla.org/globalmessagemanager;1"]
+                       .getService(Ci.nsIMessageListenerManager);
+
+var gLogger;
+var gLogAppenderDump = null;
+
+function configureLogging() {
+  if (!gLogger) {
+    gLogger = Log.repository.getLogger("Toolkit.GMP");
+    gLogger.addAppender(new Log.ConsoleAppender(new Log.BasicFormatter()));
+  }
+  gLogger.level = GMPPrefs.get(GMPPrefs.KEY_LOGGING_LEVEL, Log.Level.Warn);
+
+  let logDumping = GMPPrefs.get(GMPPrefs.KEY_LOGGING_DUMP, false);
+  if (logDumping != !!gLogAppenderDump) {
+    if (logDumping) {
+      gLogAppenderDump = new Log.DumpAppender(new Log.BasicFormatter());
+      gLogger.addAppender(gLogAppenderDump);
+    } else {
+      gLogger.removeAppender(gLogAppenderDump);
+      gLogAppenderDump = null;
+    }
+  }
+}
+
+
+
+/**
+ * The GMPWrapper provides the info for the various GMP plugins to public
+ * callers through the API.
+ */
+function GMPWrapper(aPluginInfo) {
+  this._plugin = aPluginInfo;
+  this._log =
+    Log.repository.getLoggerWithMessagePrefix("Toolkit.GMP",
+                                              "GMPWrapper(" +
+                                              this._plugin.id + ") ");
+  Preferences.observe(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_ENABLED,
+                                          this._plugin.id),
+                      this.onPrefEnabledChanged, this);
+  Preferences.observe(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_VERSION,
+                                          this._plugin.id),
+                      this.onPrefVersionChanged, this);
+  if (this._plugin.isEME) {
+    Preferences.observe(GMPPrefs.KEY_EME_ENABLED,
+                        this.onPrefEMEGlobalEnabledChanged, this);
+    messageManager.addMessageListener("EMEVideo:ContentMediaKeysRequest", this);
+  }
+}
+
+GMPWrapper.prototype = {
+  // An active task that checks for plugin updates and installs them.
+  _updateTask: null,
+  _gmpPath: null,
+  _isUpdateCheckPending: false,
+
+  optionsType: AddonManager.OPTIONS_TYPE_INLINE,
+  get optionsURL() { return this._plugin.optionsURL; },
+
+  set gmpPath(aPath) { this._gmpPath = aPath; },
+  get gmpPath() {
+    if (!this._gmpPath && this.isInstalled) {
+      this._gmpPath = OS.Path.join(OS.Constants.Path.profileDir,
+                                   this._plugin.id,
+                                   GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION,
+                                                null, this._plugin.id));
+    }
+    return this._gmpPath;
+  },
+
+  get id() { return this._plugin.id; },
+  get type() { return "plugin"; },
+  get isGMPlugin() { return true; },
+  get name() { return this._plugin.name; },
+  get creator() { return null; },
+  get homepageURL() { return this._plugin.homepageURL; },
+
+  get description() { return this._plugin.description; },
+  get fullDescription() { return this._plugin.fullDescription; },
+
+  get version() { return GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION, null,
+                                      this._plugin.id); },
+
+  get isActive() {
+    return !this.appDisabled &&
+           !this.userDisabled &&
+           !GMPUtils.isPluginHidden(this._plugin);
+  },
+  get appDisabled() {
+    if (this._plugin.isEME && !GMPPrefs.get(GMPPrefs.KEY_EME_ENABLED, true)) {
+      // If "media.eme.enabled" is false, all EME plugins are disabled.
+      return true;
+    }
+    return false;
+  },
+
+  get userDisabled() {
+    return !GMPPrefs.get(GMPPrefs.KEY_PLUGIN_ENABLED, true, this._plugin.id);
+  },
+  set userDisabled(aVal) { GMPPrefs.set(GMPPrefs.KEY_PLUGIN_ENABLED,
+                                        aVal === false,
+                                        this._plugin.id); },
+
+  get blocklistState() { return Ci.nsIBlocklistService.STATE_NOT_BLOCKED; },
+  get size() { return 0; },
+  get scope() { return AddonManager.SCOPE_APPLICATION; },
+  get pendingOperations() { return AddonManager.PENDING_NONE; },
+
+  get operationsRequiringRestart() { return AddonManager.OP_NEEDS_RESTART_NONE },
+
+  get permissions() {
+    let permissions = 0;
+    if (!this.appDisabled) {
+      permissions |= AddonManager.PERM_CAN_UPGRADE;
+      permissions |= this.userDisabled ? AddonManager.PERM_CAN_ENABLE :
+                                         AddonManager.PERM_CAN_DISABLE;
+    }
+    return permissions;
+  },
+
+  get updateDate() {
+    let time = Number(GMPPrefs.get(GMPPrefs.KEY_PLUGIN_LAST_UPDATE, null,
+                                   this._plugin.id));
+    if (!isNaN(time) && this.isInstalled) {
+      return new Date(time * 1000)
+    }
+    return null;
+  },
+
+  get isCompatible() {
+    return true;
+  },
+
+  get isPlatformCompatible() {
+    return true;
+  },
+
+  get providesUpdatesSecurely() {
+    return true;
+  },
+
+  get foreignInstall() {
+    return false;
+  },
+
+  isCompatibleWith: function(aAppVersion, aPlatformVersion) {
+    return true;
+  },
+
+  get applyBackgroundUpdates() {
+    if (!GMPPrefs.isSet(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, this._plugin.id)) {
+      return AddonManager.AUTOUPDATE_DEFAULT;
+    }
+
+    return GMPPrefs.get(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, true, this._plugin.id) ?
+      AddonManager.AUTOUPDATE_ENABLE : AddonManager.AUTOUPDATE_DISABLE;
+  },
+
+  set applyBackgroundUpdates(aVal) {
+    if (aVal == AddonManager.AUTOUPDATE_DEFAULT) {
+      GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, this._plugin.id);
+    } else if (aVal == AddonManager.AUTOUPDATE_ENABLE) {
+      GMPPrefs.set(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, true, this._plugin.id);
+    } else if (aVal == AddonManager.AUTOUPDATE_DISABLE) {
+      GMPPrefs.set(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, false, this._plugin.id);
+    }
+  },
+
+  findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) {
+    this._log.trace("findUpdates() - " + this._plugin.id + " - reason=" +
+                    aReason);
+
+    AddonManagerPrivate.callNoUpdateListeners(this, aListener);
+
+    if (aReason === AddonManager.UPDATE_WHEN_PERIODIC_UPDATE) {
+      if (!AddonManager.shouldAutoUpdate(this)) {
+        this._log.trace("findUpdates() - " + this._plugin.id +
+                        " - no autoupdate");
+        return Promise.resolve(false);
+      }
+
+      let secSinceLastCheck =
+        Date.now() / 1000 - Preferences.get(GMPPrefs.KEY_UPDATE_LAST_CHECK, 0);
+      if (secSinceLastCheck <= SEC_IN_A_DAY) {
+        this._log.trace("findUpdates() - " + this._plugin.id +
+                        " - last check was less then a day ago");
+        return Promise.resolve(false);
+      }
+    } else if (aReason !== AddonManager.UPDATE_WHEN_USER_REQUESTED) {
+      this._log.trace("findUpdates() - " + this._plugin.id +
+                      " - the given reason to update is not supported");
+      return Promise.resolve(false);
+    }
+
+    if (this._updateTask !== null) {
+      this._log.trace("findUpdates() - " + this._plugin.id +
+                      " - update task already running");
+      return this._updateTask;
+    }
+
+    this._updateTask = Task.spawn(function*() {
+      this._log.trace("findUpdates() - updateTask");
+      try {
+        let installManager = new GMPInstallManager();
+        let res = yield installManager.checkForAddons();
+        let update = res.gmpAddons.find(addon => addon.id === this._plugin.id);
+        if (update && update.isValid && !update.isInstalled) {
+          this._log.trace("findUpdates() - found update for " +
+                          this._plugin.id + ", installing");
+          yield installManager.installAddon(update);
+        } else {
+          this._log.trace("findUpdates() - no updates for " + this._plugin.id);
+        }
+        this._log.info("findUpdates() - updateTask succeeded for " +
+                       this._plugin.id);
+      } catch (e) {
+        this._log.error("findUpdates() - updateTask for " + this._plugin.id +
+                        " threw", e);
+        throw e;
+      } finally {
+        this._updateTask = null;
+        return true;
+      }
+    }.bind(this));
+
+    return this._updateTask;
+  },
+
+  get pluginMimeTypes() { return []; },
+  get pluginLibraries() {
+    if (this.isInstalled) {
+      let path = this.version;
+      return [path];
+    }
+    return [];
+  },
+  get pluginFullpath() {
+    if (this.isInstalled) {
+      let path = OS.Path.join(OS.Constants.Path.profileDir,
+                              this._plugin.id,
+                              this.version);
+      return [path];
+    }
+    return [];
+  },
+
+  get isInstalled() {
+    return this.version && this.version.length > 0;
+  },
+
+  _handleEnabledChanged: function() {
+    this._log.info("_handleEnabledChanged() id=" +
+      this._plugin.id + " isActive=" + this.isActive);
+
+    AddonManagerPrivate.callAddonListeners(this.isActive ?
+                                           "onEnabling" : "onDisabling",
+                                           this, false);
+    if (this._gmpPath) {
+      if (this.isActive) {
+        this._log.info("onPrefEnabledChanged() - adding gmp directory " +
+                       this._gmpPath);
+        gmpService.addPluginDirectory(this._gmpPath);
+      } else {
+        this._log.info("onPrefEnabledChanged() - removing gmp directory " +
+                       this._gmpPath);
+        gmpService.removePluginDirectory(this._gmpPath);
+      }
+    }
+    AddonManagerPrivate.callAddonListeners(this.isActive ?
+                                           "onEnabled" : "onDisabled",
+                                           this);
+  },
+
+  onPrefEMEGlobalEnabledChanged: function() {
+    this._log.info("onPrefEMEGlobalEnabledChanged() id=" + this._plugin.id +
+      " appDisabled=" + this.appDisabled + " isActive=" + this.isActive +
+      " hidden=" + GMPUtils.isPluginHidden(this._plugin));
+
+    AddonManagerPrivate.callAddonListeners("onPropertyChanged", this,
+                                           ["appDisabled"]);
+    // If EME or the GMP itself are disabled, uninstall the GMP.
+    // Otherwise, check for updates, so we download and install the GMP.
+    if (this.appDisabled) {
+      this.uninstallPlugin();
+    } else if (!GMPUtils.isPluginHidden(this._plugin)) {
+      AddonManagerPrivate.callInstallListeners("onExternalInstall", null, this,
+                                               null, false);
+      AddonManagerPrivate.callAddonListeners("onInstalling", this, false);
+      AddonManagerPrivate.callAddonListeners("onInstalled", this);
+      this.checkForUpdates(GMP_CHECK_DELAY);
+    }
+    if (!this.userDisabled) {
+      this._handleEnabledChanged();
+    }
+  },
+
+  checkForUpdates: function(delay) {
+    if (this._isUpdateCheckPending) {
+      return;
+    }
+    this._isUpdateCheckPending = true;
+    GMPPrefs.reset(GMPPrefs.KEY_UPDATE_LAST_CHECK, null);
+    // Delay this in case the user changes his mind and doesn't want to
+    // enable EME after all.
+    setTimeout(() => {
+      if (!this.appDisabled) {
+        let gmpInstallManager = new GMPInstallManager();
+        // We don't really care about the results, if someone is interested
+        // they can check the log.
+        gmpInstallManager.simpleCheckAndInstall().then(null, () => {});
+      }
+      this._isUpdateCheckPending = false;
+    }, delay);
+  },
+
+  receiveMessage: function({target: browser, data: data}) {
+    this._log.trace("receiveMessage() data=" + data);
+    let parsedData;
+    try {
+      parsedData = JSON.parse(data);
+    } catch (ex) {
+      this._log.error("Malformed EME video message with data: " + data);
+      return;
+    }
+    let {status: status, keySystem: keySystem} = parsedData;
+    if (status == "cdm-not-installed") {
+      this.checkForUpdates(0);
+    }
+  },
+
+  onPrefEnabledChanged: function() {
+    if (!this._plugin.isEME || !this.appDisabled) {
+      this._handleEnabledChanged();
+    }
+  },
+
+  onPrefVersionChanged: function() {
+    AddonManagerPrivate.callAddonListeners("onUninstalling", this, false);
+    if (this._gmpPath) {
+      this._log.info("onPrefVersionChanged() - unregistering gmp directory " +
+                     this._gmpPath);
+      gmpService.removeAndDeletePluginDirectory(this._gmpPath, true /* can defer */);
+    }
+    AddonManagerPrivate.callAddonListeners("onUninstalled", this);
+
+    AddonManagerPrivate.callInstallListeners("onExternalInstall", null, this,
+                                             null, false);
+    AddonManagerPrivate.callAddonListeners("onInstalling", this, false);
+    this._gmpPath = null;
+    if (this.isInstalled) {
+      this._gmpPath = OS.Path.join(OS.Constants.Path.profileDir,
+                                   this._plugin.id,
+                                   GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION,
+                                                null, this._plugin.id));
+    }
+    if (this._gmpPath && this.isActive) {
+      this._log.info("onPrefVersionChanged() - registering gmp directory " +
+                     this._gmpPath);
+      gmpService.addPluginDirectory(this._gmpPath);
+    }
+    AddonManagerPrivate.callAddonListeners("onInstalled", this);
+  },
+
+  uninstallPlugin: function() {
+    AddonManagerPrivate.callAddonListeners("onUninstalling", this, false);
+    if (this.gmpPath) {
+      this._log.info("uninstallPlugin() - unregistering gmp directory " +
+                     this.gmpPath);
+      gmpService.removeAndDeletePluginDirectory(this.gmpPath);
+    }
+    GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_VERSION, this.id);
+    GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_ABI, this.id);
+    GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_LAST_UPDATE, this.id);
+    AddonManagerPrivate.callAddonListeners("onUninstalled", this);
+  },
+
+  shutdown: function() {
+    Preferences.ignore(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_ENABLED,
+                                           this._plugin.id),
+                       this.onPrefEnabledChanged, this);
+    Preferences.ignore(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_VERSION,
+                                           this._plugin.id),
+                       this.onPrefVersionChanged, this);
+    if (this._plugin.isEME) {
+      Preferences.ignore(GMPPrefs.KEY_EME_ENABLED,
+                         this.onPrefEMEGlobalEnabledChanged, this);
+      messageManager.removeMessageListener("EMEVideo:ContentMediaKeysRequest", this);
+    }
+    return this._updateTask;
+  },
+
+  _arePluginFilesOnDisk: function() {
+    let fileExists = function(aGmpPath, aFileName) {
+      let f = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+      let path = OS.Path.join(aGmpPath, aFileName);
+      f.initWithPath(path);
+      return f.exists();
+    };
+
+    let id = this._plugin.id.substring(4);
+    let libName = AppConstants.DLL_PREFIX + id + AppConstants.DLL_SUFFIX;
+    let infoName;
+    if (this._plugin.id == WIDEVINE_ID) {
+      infoName = "manifest.json";
+    } else {
+      infoName = id + ".info";
+    }
+
+    return fileExists(this.gmpPath, libName) &&
+           fileExists(this.gmpPath, infoName) &&
+           (this._plugin.id != EME_ADOBE_ID || fileExists(this.gmpPath, id + ".voucher"));
+  },
+
+  validate: function() {
+    if (!this.isInstalled) {
+      // Not installed -> Valid.
+      return {
+        installed: false,
+        valid: true
+      };
+    }
+
+    let abi = GMPPrefs.get(GMPPrefs.KEY_PLUGIN_ABI, UpdateUtils.ABI, this._plugin.id);
+    if (abi != UpdateUtils.ABI) {
+      // ABI doesn't match. Possibly this is a profile migrated across platforms
+      // or from 32 -> 64 bit.
+      return {
+        installed: true,
+        mismatchedABI: true,
+        valid: false
+      };
+    }
+
+    // Installed -> Check if files are missing.
+    let filesOnDisk = this._arePluginFilesOnDisk();
+    return {
+      installed: true,
+      valid: filesOnDisk
+    };
+  },
+};
+
+var GMPProvider = {
+  get name() { return "GMPProvider"; },
+
+  _plugins: null,
+
+  startup: function() {
+    configureLogging();
+    this._log = Log.repository.getLoggerWithMessagePrefix("Toolkit.GMP",
+                                                          "GMPProvider.");
+    this.buildPluginList();
+    this.ensureProperCDMInstallState();
+
+    Preferences.observe(GMPPrefs.KEY_LOG_BASE, configureLogging);
+
+    for (let [id, plugin] of this._plugins) {
+      let wrapper = plugin.wrapper;
+      let gmpPath = wrapper.gmpPath;
+      let isEnabled = wrapper.isActive;
+      this._log.trace("startup - enabled=" + isEnabled + ", gmpPath=" +
+                      gmpPath);
+
+      if (gmpPath && isEnabled) {
+        let validation = wrapper.validate();
+        if (validation.mismatchedABI) {
+          this._log.info("startup - gmp " + plugin.id +
+                         " mismatched ABI, uninstalling");
+          wrapper.uninstallPlugin();
+          continue;
+        }
+        if (!validation.valid) {
+          this._log.info("startup - gmp " + plugin.id +
+                         " invalid, uninstalling");
+          wrapper.uninstallPlugin();
+          continue;
+        }
+        this._log.info("startup - adding gmp directory " + gmpPath);
+        try {
+          gmpService.addPluginDirectory(gmpPath);
+        } catch (e) {
+          if (e.name != 'NS_ERROR_NOT_AVAILABLE')
+            throw e;
+          this._log.warn("startup - adding gmp directory failed with " +
+                         e.name + " - sandboxing not available?", e);
+        }
+      }
+    }
+
+    try {
+      let greDir = Services.dirsvc.get(NS_GRE_DIR,
+                                       Ci.nsILocalFile);
+      let clearkeyPath = OS.Path.join(greDir.path,
+                                      CLEARKEY_PLUGIN_ID,
+                                      CLEARKEY_VERSION);
+      this._log.info("startup - adding clearkey CDM directory " +
+                     clearkeyPath);
+      gmpService.addPluginDirectory(clearkeyPath);
+    } catch (e) {
+      this._log.warn("startup - adding clearkey CDM failed", e);
+    }
+  },
+
+  shutdown: function() {
+    this._log.trace("shutdown");
+    Preferences.ignore(GMPPrefs.KEY_LOG_BASE, configureLogging);
+
+    let shutdownTask = Task.spawn(function*() {
+      this._log.trace("shutdown - shutdownTask");
+      let shutdownSucceeded = true;
+
+      for (let plugin of this._plugins.values()) {
+        try {
+          yield plugin.wrapper.shutdown();
+        } catch (e) {
+          shutdownSucceeded = false;
+        }
+      }
+
+      this._plugins = null;
+
+      if (!shutdownSucceeded) {
+        throw new Error("Shutdown failed");
+      }
+    }.bind(this));
+
+    return shutdownTask;
+  },
+
+  getAddonByID: function(aId, aCallback) {
+    if (!this.isEnabled) {
+      aCallback(null);
+      return;
+    }
+
+    let plugin = this._plugins.get(aId);
+    if (plugin && !GMPUtils.isPluginHidden(plugin)) {
+      aCallback(plugin.wrapper);
+    } else {
+      aCallback(null);
+    }
+  },
+
+  getAddonsByTypes: function(aTypes, aCallback) {
+    if (!this.isEnabled ||
+        (aTypes && aTypes.indexOf("plugin") < 0)) {
+      aCallback([]);
+      return;
+    }
+
+    let results = Array.from(this._plugins.values())
+      .filter(p => !GMPUtils.isPluginHidden(p))
+      .map(p => p.wrapper);
+
+    aCallback(results);
+  },
+
+  get isEnabled() {
+    return GMPPrefs.get(GMPPrefs.KEY_PROVIDER_ENABLED, false);
+  },
+
+  generateFullDescription: function(aPlugin) {
+    let rv = [];
+    for (let [urlProp, labelId] of [["learnMoreURL", GMP_LEARN_MORE],
+                                    ["licenseURL", aPlugin.id == WIDEVINE_ID ?
+                                     GMP_PRIVACY_INFO : GMP_LICENSE_INFO]]) {
+      if (aPlugin[urlProp]) {
+        let label = pluginsBundle.GetStringFromName(labelId);
+        rv.push(`<xhtml:a href="${aPlugin[urlProp]}" target="_blank">${label}</xhtml:a>.`);
+      }
+    }
+    return rv.length ? rv.join("<xhtml:br /><xhtml:br />") : undefined;
+  },
+
+  buildPluginList: function() {
+    this._plugins = new Map();
+    for (let aPlugin of GMP_PLUGINS) {
+      let plugin = {
+        id: aPlugin.id,
+        name: pluginsBundle.GetStringFromName(aPlugin.name),
+        description: pluginsBundle.GetStringFromName(aPlugin.description),
+        homepageURL: aPlugin.homepageURL,
+        optionsURL: aPlugin.optionsURL,
+        wrapper: null,
+        isEME: aPlugin.isEME,
+      };
+      plugin.fullDescription = this.generateFullDescription(aPlugin);
+      plugin.wrapper = new GMPWrapper(plugin);
+      this._plugins.set(plugin.id, plugin);
+    }
+  },
+
+  ensureProperCDMInstallState: function() {
+    if (!GMPPrefs.get(GMPPrefs.KEY_EME_ENABLED, true)) {
+      for (let [id, plugin] of this._plugins) {
+        if (plugin.isEME && plugin.wrapper.isInstalled) {
+          gmpService.addPluginDirectory(plugin.wrapper.gmpPath);
+          plugin.wrapper.uninstallPlugin();
+        }
+      }
+    }
+  },
+};
+
+AddonManagerPrivate.registerProvider(GMPProvider, [
+  new AddonManagerPrivate.AddonType("plugin", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 6000,
+                                    AddonManager.TYPE_SUPPORTS_ASK_TO_ACTIVATE)
+]);
diff --git a/toolkit/mozapps/webextensions/internal/LightweightThemeImageOptimizer.jsm b/toolkit/mozapps/webextensions/internal/LightweightThemeImageOptimizer.jsm
new file mode 100644
index 000000000..49dfa237f
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/LightweightThemeImageOptimizer.jsm
@@ -0,0 +1,180 @@
+/* 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";
+
+this.EXPORTED_SYMBOLS = ["LightweightThemeImageOptimizer"];
+
+const Cu = Components.utils;
+const Ci = Components.interfaces;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "Services",
+  "resource://gre/modules/Services.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+  "resource://gre/modules/FileUtils.jsm");
+
+const ORIGIN_TOP_RIGHT = 1;
+const ORIGIN_BOTTOM_LEFT = 2;
+
+this.LightweightThemeImageOptimizer = {
+  optimize: function(aThemeData, aScreen) {
+    let data = Object.assign({}, aThemeData);
+    if (!data.headerURL) {
+      return data;
+    }
+
+    data.headerURL = ImageCropper.getCroppedImageURL(
+      data.headerURL, aScreen, ORIGIN_TOP_RIGHT);
+
+    if (data.footerURL) {
+      data.footerURL = ImageCropper.getCroppedImageURL(
+        data.footerURL, aScreen, ORIGIN_BOTTOM_LEFT);
+    }
+
+    return data;
+  },
+
+  purge: function() {
+    let dir = FileUtils.getDir("ProfD", ["lwtheme"]);
+    dir.followLinks = false;
+    try {
+      dir.remove(true);
+    } catch (e) {}
+  }
+};
+
+Object.freeze(LightweightThemeImageOptimizer);
+
+var ImageCropper = {
+  _inProgress: {},
+
+  getCroppedImageURL: function(aImageURL, aScreen, aOrigin) {
+    // We can crop local files, only.
+    if (!aImageURL.startsWith("file://")) {
+      return aImageURL;
+    }
+
+    // Generate the cropped image's file name using its
+    // base name and the current screen size.
+    let uri = Services.io.newURI(aImageURL, null, null);
+    let file = uri.QueryInterface(Ci.nsIFileURL).file;
+
+    // Make sure the source file exists.
+    if (!file.exists()) {
+      return aImageURL;
+    }
+
+    let fileName = file.leafName + "-" + aScreen.width + "x" + aScreen.height;
+    let croppedFile = FileUtils.getFile("ProfD", ["lwtheme", fileName]);
+
+    // If we have a local file that is not in progress, return it.
+    if (croppedFile.exists() && !(croppedFile.path in this._inProgress)) {
+      let fileURI = Services.io.newFileURI(croppedFile);
+
+      // Copy the query part to avoid wrong caching.
+      fileURI.QueryInterface(Ci.nsIURL).query = uri.query;
+      return fileURI.spec;
+    }
+
+    // Crop the given image in the background.
+    this._crop(uri, croppedFile, aScreen, aOrigin);
+
+    // Return the original image while we're waiting for the cropped version
+    // to be written to disk.
+    return aImageURL;
+  },
+
+  _crop: function(aURI, aTargetFile, aScreen, aOrigin) {
+    let inProgress = this._inProgress;
+    inProgress[aTargetFile.path] = true;
+
+    function resetInProgress() {
+      delete inProgress[aTargetFile.path];
+    }
+
+    ImageFile.read(aURI, function(aInputStream, aContentType) {
+      if (aInputStream && aContentType) {
+        let image = ImageTools.decode(aInputStream, aContentType);
+        if (image && image.width && image.height) {
+          let stream = ImageTools.encode(image, aScreen, aOrigin, aContentType);
+          if (stream) {
+            ImageFile.write(aTargetFile, stream, resetInProgress);
+            return;
+          }
+        }
+      }
+
+      resetInProgress();
+    });
+  }
+};
+
+var ImageFile = {
+  read: function(aURI, aCallback) {
+    this._netUtil.asyncFetch({
+      uri: aURI,
+      loadUsingSystemPrincipal: true,
+      contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE
+    }, function(aInputStream, aStatus, aRequest) {
+        if (Components.isSuccessCode(aStatus) && aRequest instanceof Ci.nsIChannel) {
+          let channel = aRequest.QueryInterface(Ci.nsIChannel);
+          aCallback(aInputStream, channel.contentType);
+        } else {
+          aCallback();
+        }
+      });
+  },
+
+  write: function(aFile, aInputStream, aCallback) {
+    let fos = FileUtils.openSafeFileOutputStream(aFile);
+    this._netUtil.asyncCopy(aInputStream, fos, function(aResult) {
+      FileUtils.closeSafeFileOutputStream(fos);
+
+      // Remove the file if writing was not successful.
+      if (!Components.isSuccessCode(aResult)) {
+        try {
+          aFile.remove(false);
+        } catch (e) {}
+      }
+
+      aCallback();
+    });
+  }
+};
+
+XPCOMUtils.defineLazyModuleGetter(ImageFile, "_netUtil",
+  "resource://gre/modules/NetUtil.jsm", "NetUtil");
+
+var ImageTools = {
+  decode: function(aInputStream, aContentType) {
+    let outParam = {value: null};
+
+    try {
+      this._imgTools.decodeImageData(aInputStream, aContentType, outParam);
+    } catch (e) {}
+
+    return outParam.value;
+  },
+
+  encode: function(aImage, aScreen, aOrigin, aContentType) {
+    let stream;
+    let width = Math.min(aImage.width, aScreen.width);
+    let height = Math.min(aImage.height, aScreen.height);
+    let x = aOrigin == ORIGIN_TOP_RIGHT ? aImage.width - width : 0;
+
+    try {
+      stream = this._imgTools.encodeCroppedImage(aImage, aContentType, x, 0,
+                                                 width, height);
+    } catch (e) {}
+
+    return stream;
+  }
+};
+
+XPCOMUtils.defineLazyServiceGetter(ImageTools, "_imgTools",
+  "@mozilla.org/image/tools;1", "imgITools");
+
diff --git a/toolkit/mozapps/webextensions/internal/PluginProvider.jsm b/toolkit/mozapps/webextensions/internal/PluginProvider.jsm
new file mode 100644
index 000000000..075159a9a
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/PluginProvider.jsm
@@ -0,0 +1,600 @@
+/* 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 Cu = Components.utils;
+
+this.EXPORTED_SYMBOLS = [];
+
+Cu.import("resource://gre/modules/AddonManager.jsm");
+/* globals AddonManagerPrivate*/
+Cu.import("resource://gre/modules/Services.jsm");
+
+const URI_EXTENSION_STRINGS  = "chrome://mozapps/locale/extensions/extensions.properties";
+const STRING_TYPE_NAME       = "type.%ID%.name";
+const LIST_UPDATED_TOPIC     = "plugins-list-updated";
+const FLASH_MIME_TYPE        = "application/x-shockwave-flash";
+
+Cu.import("resource://gre/modules/Log.jsm");
+const LOGGER_ID = "addons.plugins";
+
+// Create a new logger for use by the Addons Plugin Provider
+// (Requires AddonManager.jsm)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+function getIDHashForString(aStr) {
+  // return the two-digit hexadecimal code for a byte
+  let toHexString = charCode => ("0" + charCode.toString(16)).slice(-2);
+
+  let hasher = Cc["@mozilla.org/security/hash;1"].
+               createInstance(Ci.nsICryptoHash);
+  hasher.init(Ci.nsICryptoHash.MD5);
+  let stringStream = Cc["@mozilla.org/io/string-input-stream;1"].
+                     createInstance(Ci.nsIStringInputStream);
+                     stringStream.data = aStr ? aStr : "null";
+  hasher.updateFromStream(stringStream, -1);
+
+  // convert the binary hash data to a hex string.
+  let binary = hasher.finish(false);
+  let hash = Array.from(binary, c => toHexString(c.charCodeAt(0)));
+  hash = hash.join("").toLowerCase();
+  return "{" + hash.substr(0, 8) + "-" +
+               hash.substr(8, 4) + "-" +
+               hash.substr(12, 4) + "-" +
+               hash.substr(16, 4) + "-" +
+               hash.substr(20) + "}";
+}
+
+var PluginProvider = {
+  get name() {
+    return "PluginProvider";
+  },
+
+  // A dictionary mapping IDs to names and descriptions
+  plugins: null,
+
+  startup: function() {
+    Services.obs.addObserver(this, LIST_UPDATED_TOPIC, false);
+    Services.obs.addObserver(this, AddonManager.OPTIONS_NOTIFICATION_DISPLAYED, false);
+  },
+
+  /**
+   * Called when the application is shutting down. Only necessary for tests
+   * to be able to simulate a shutdown.
+   */
+  shutdown: function() {
+    this.plugins = null;
+    Services.obs.removeObserver(this, AddonManager.OPTIONS_NOTIFICATION_DISPLAYED);
+    Services.obs.removeObserver(this, LIST_UPDATED_TOPIC);
+  },
+
+  observe: function(aSubject, aTopic, aData) {
+    switch (aTopic) {
+    case AddonManager.OPTIONS_NOTIFICATION_DISPLAYED:
+      this.getAddonByID(aData, function(plugin) {
+        if (!plugin)
+          return;
+
+        let libLabel = aSubject.getElementById("pluginLibraries");
+        libLabel.textContent = plugin.pluginLibraries.join(", ");
+
+        let typeLabel = aSubject.getElementById("pluginMimeTypes"), types = [];
+        for (let type of plugin.pluginMimeTypes) {
+          let extras = [type.description.trim(), type.suffixes].
+                       filter(x => x).join(": ");
+          types.push(type.type + (extras ? " (" + extras + ")" : ""));
+        }
+        typeLabel.textContent = types.join(",\n");
+        let showProtectedModePref = canDisableFlashProtectedMode(plugin);
+        aSubject.getElementById("pluginEnableProtectedMode")
+          .setAttribute("collapsed", showProtectedModePref ? "" : "true");
+      });
+      break;
+    case LIST_UPDATED_TOPIC:
+      if (this.plugins)
+        this.updatePluginList();
+      break;
+    }
+  },
+
+  /**
+   * Creates a PluginWrapper for a plugin object.
+   */
+  buildWrapper: function(aPlugin) {
+    return new PluginWrapper(aPlugin.id,
+                             aPlugin.name,
+                             aPlugin.description,
+                             aPlugin.tags);
+  },
+
+  /**
+   * Called to get an Addon with a particular ID.
+   *
+   * @param  aId
+   *         The ID of the add-on to retrieve
+   * @param  aCallback
+   *         A callback to pass the Addon to
+   */
+  getAddonByID: function(aId, aCallback) {
+    if (!this.plugins)
+      this.buildPluginList();
+
+    if (aId in this.plugins)
+      aCallback(this.buildWrapper(this.plugins[aId]));
+    else
+      aCallback(null);
+  },
+
+  /**
+   * Called to get Addons of a particular type.
+   *
+   * @param  aTypes
+   *         An array of types to fetch. Can be null to get all types.
+   * @param  callback
+   *         A callback to pass an array of Addons to
+   */
+  getAddonsByTypes: function(aTypes, aCallback) {
+    if (aTypes && aTypes.indexOf("plugin") < 0) {
+      aCallback([]);
+      return;
+    }
+
+    if (!this.plugins)
+      this.buildPluginList();
+
+    let results = [];
+
+    for (let id in this.plugins)
+      this.getAddonByID(id, (addon) => results.push(addon));
+
+    aCallback(results);
+  },
+
+  /**
+   * Called to get Addons that have pending operations.
+   *
+   * @param  aTypes
+   *         An array of types to fetch. Can be null to get all types
+   * @param  aCallback
+   *         A callback to pass an array of Addons to
+   */
+  getAddonsWithOperationsByTypes: function(aTypes, aCallback) {
+    aCallback([]);
+  },
+
+  /**
+   * Called to get the current AddonInstalls, optionally restricting by type.
+   *
+   * @param  aTypes
+   *         An array of types or null to get all types
+   * @param  aCallback
+   *         A callback to pass the array of AddonInstalls to
+   */
+  getInstallsByTypes: function(aTypes, aCallback) {
+    aCallback([]);
+  },
+
+  /**
+   * Builds a list of the current plugins reported by the plugin host
+   *
+   * @return a dictionary of plugins indexed by our generated ID
+   */
+  getPluginList: function() {
+    let tags = Cc["@mozilla.org/plugin/host;1"].
+               getService(Ci.nsIPluginHost).
+               getPluginTags({});
+
+    let list = {};
+    let seenPlugins = {};
+    for (let tag of tags) {
+      if (!(tag.name in seenPlugins))
+        seenPlugins[tag.name] = {};
+      if (!(tag.description in seenPlugins[tag.name])) {
+        let plugin = {
+          id: getIDHashForString(tag.name + tag.description),
+          name: tag.name,
+          description: tag.description,
+          tags: [tag]
+        };
+
+        seenPlugins[tag.name][tag.description] = plugin;
+        list[plugin.id] = plugin;
+      }
+      else {
+        seenPlugins[tag.name][tag.description].tags.push(tag);
+      }
+    }
+
+    return list;
+  },
+
+  /**
+   * Builds the list of known plugins from the plugin host
+   */
+  buildPluginList: function() {
+    this.plugins = this.getPluginList();
+  },
+
+  /**
+   * Updates the plugins from the plugin host by comparing the current plugins
+   * to the last known list sending out any necessary API notifications for
+   * changes.
+   */
+  updatePluginList: function() {
+    let newList = this.getPluginList();
+
+    let lostPlugins = Object.keys(this.plugins).filter(id => !(id in newList)).
+                      map(id => this.buildWrapper(this.plugins[id]));
+    let newPlugins = Object.keys(newList).filter(id => !(id in this.plugins)).
+                     map(id => this.buildWrapper(newList[id]));
+    let matchedIDs = Object.keys(newList).filter(id => id in this.plugins);
+
+    // The plugin host generates new tags for every plugin after a scan and
+    // if the plugin's filename has changed then the disabled state won't have
+    // been carried across, send out notifications for anything that has
+    // changed (see bug 830267).
+    let changedWrappers = [];
+    for (let id of matchedIDs) {
+      let oldWrapper = this.buildWrapper(this.plugins[id]);
+      let newWrapper = this.buildWrapper(newList[id]);
+
+      if (newWrapper.isActive != oldWrapper.isActive) {
+        AddonManagerPrivate.callAddonListeners(newWrapper.isActive ?
+                                               "onEnabling" : "onDisabling",
+                                               newWrapper, false);
+        changedWrappers.push(newWrapper);
+      }
+    }
+
+    // Notify about new installs
+    for (let plugin of newPlugins) {
+      AddonManagerPrivate.callInstallListeners("onExternalInstall", null,
+                                               plugin, null, false);
+      AddonManagerPrivate.callAddonListeners("onInstalling", plugin, false);
+    }
+
+    // Notify for any plugins that have vanished.
+    for (let plugin of lostPlugins)
+      AddonManagerPrivate.callAddonListeners("onUninstalling", plugin, false);
+
+    this.plugins = newList;
+
+    // Signal that new installs are complete
+    for (let plugin of newPlugins)
+      AddonManagerPrivate.callAddonListeners("onInstalled", plugin);
+
+    // Signal that enables/disables are complete
+    for (let wrapper of changedWrappers) {
+      AddonManagerPrivate.callAddonListeners(wrapper.isActive ?
+                                             "onEnabled" : "onDisabled",
+                                             wrapper);
+    }
+
+    // Signal that uninstalls are complete
+    for (let plugin of lostPlugins)
+      AddonManagerPrivate.callAddonListeners("onUninstalled", plugin);
+  }
+};
+
+function isFlashPlugin(aPlugin) {
+  for (let type of aPlugin.pluginMimeTypes) {
+    if (type.type == FLASH_MIME_TYPE) {
+      return true;
+    }
+  }
+  return false;
+}
+// Protected mode is win32-only, not win64
+function canDisableFlashProtectedMode(aPlugin) {
+  return isFlashPlugin(aPlugin) && Services.appinfo.XPCOMABI == "x86-msvc";
+}
+
+const wrapperMap = new WeakMap();
+let pluginFor = wrapper => wrapperMap.get(wrapper);
+
+/**
+ * The PluginWrapper wraps a set of nsIPluginTags to provide the data visible to
+ * public callers through the API.
+ */
+function PluginWrapper(id, name, description, tags) {
+  wrapperMap.set(this, { id, name, description, tags });
+}
+
+PluginWrapper.prototype = {
+  get id() {
+    return pluginFor(this).id;
+  },
+
+  get type() {
+    return "plugin";
+  },
+
+  get name() {
+    return pluginFor(this).name;
+  },
+
+  get creator() {
+    return null;
+  },
+
+  get description() {
+    return pluginFor(this).description.replace(/<\/?[a-z][^>]*>/gi, " ");
+  },
+
+  get version() {
+    let { tags: [tag] } = pluginFor(this);
+    return tag.version;
+  },
+
+  get homepageURL() {
+    let { description } = pluginFor(this);
+    if (/<A\s+HREF=[^>]*>/i.test(description))
+      return /<A\s+HREF=["']?([^>"'\s]*)/i.exec(description)[1];
+    return null;
+  },
+
+  get isActive() {
+    let { tags: [tag] } = pluginFor(this);
+    return !tag.blocklisted && !tag.disabled;
+  },
+
+  get appDisabled() {
+    let { tags: [tag] } = pluginFor(this);
+    return tag.blocklisted;
+  },
+
+  get userDisabled() {
+    let { tags: [tag] } = pluginFor(this);
+    if (tag.disabled)
+      return true;
+
+    if ((Services.prefs.getBoolPref("plugins.click_to_play") && tag.clicktoplay) ||
+        this.blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE ||
+        this.blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE)
+      return AddonManager.STATE_ASK_TO_ACTIVATE;
+
+    return false;
+  },
+
+  set userDisabled(val) {
+    let previousVal = this.userDisabled;
+    if (val === previousVal)
+      return val;
+
+    let { tags } = pluginFor(this);
+
+    for (let tag of tags) {
+      if (val === true)
+        tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED;
+      else if (val === false)
+        tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED;
+      else if (val == AddonManager.STATE_ASK_TO_ACTIVATE)
+        tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY;
+    }
+
+    // If 'userDisabled' was 'true' and we're going to a state that's not
+    // that, we're enabling, so call those listeners.
+    if (previousVal === true && val !== true) {
+      AddonManagerPrivate.callAddonListeners("onEnabling", this, false);
+      AddonManagerPrivate.callAddonListeners("onEnabled", this);
+    }
+
+    // If 'userDisabled' was not 'true' and we're going to a state where
+    // it is, we're disabling, so call those listeners.
+    if (previousVal !== true && val === true) {
+      AddonManagerPrivate.callAddonListeners("onDisabling", this, false);
+      AddonManagerPrivate.callAddonListeners("onDisabled", this);
+    }
+
+    // If the 'userDisabled' value involved AddonManager.STATE_ASK_TO_ACTIVATE,
+    // call the onPropertyChanged listeners.
+    if (previousVal == AddonManager.STATE_ASK_TO_ACTIVATE ||
+        val == AddonManager.STATE_ASK_TO_ACTIVATE) {
+      AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["userDisabled"]);
+    }
+
+    return val;
+  },
+
+  get blocklistState() {
+    let { tags: [tag] } = pluginFor(this);
+    let bs = Cc["@mozilla.org/extensions/blocklist;1"].
+             getService(Ci.nsIBlocklistService);
+    return bs.getPluginBlocklistState(tag);
+  },
+
+  get blocklistURL() {
+    let { tags: [tag] } = pluginFor(this);
+    let bs = Cc["@mozilla.org/extensions/blocklist;1"].
+             getService(Ci.nsIBlocklistService);
+    return bs.getPluginBlocklistURL(tag);
+  },
+
+  get size() {
+    function getDirectorySize(aFile) {
+      let size = 0;
+      let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
+      let entry;
+      while ((entry = entries.nextFile)) {
+        if (entry.isSymlink() || !entry.isDirectory())
+          size += entry.fileSize;
+        else
+          size += getDirectorySize(entry);
+      }
+      entries.close();
+      return size;
+    }
+
+    let size = 0;
+    let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+    for (let tag of pluginFor(this).tags) {
+      file.initWithPath(tag.fullpath);
+      if (file.isDirectory())
+        size += getDirectorySize(file);
+      else
+        size += file.fileSize;
+    }
+    return size;
+  },
+
+  get pluginLibraries() {
+    let libs = [];
+    for (let tag of pluginFor(this).tags)
+      libs.push(tag.filename);
+    return libs;
+  },
+
+  get pluginFullpath() {
+    let paths = [];
+    for (let tag of pluginFor(this).tags)
+      paths.push(tag.fullpath);
+    return paths;
+  },
+
+  get pluginMimeTypes() {
+    let types = [];
+    for (let tag of pluginFor(this).tags) {
+      let mimeTypes = tag.getMimeTypes({});
+      let mimeDescriptions = tag.getMimeDescriptions({});
+      let extensions = tag.getExtensions({});
+      for (let i = 0; i < mimeTypes.length; i++) {
+        let type = {};
+        type.type = mimeTypes[i];
+        type.description = mimeDescriptions[i];
+        type.suffixes = extensions[i];
+
+        types.push(type);
+      }
+    }
+    return types;
+  },
+
+  get installDate() {
+    let date = 0;
+    for (let tag of pluginFor(this).tags) {
+      date = Math.max(date, tag.lastModifiedTime);
+    }
+    return new Date(date);
+  },
+
+  get scope() {
+    let { tags: [tag] } = pluginFor(this);
+    let path = tag.fullpath;
+    // Plugins inside the application directory are in the application scope
+    let dir = Services.dirsvc.get("APlugns", Ci.nsIFile);
+    if (path.startsWith(dir.path))
+      return AddonManager.SCOPE_APPLICATION;
+
+    // Plugins inside the profile directory are in the profile scope
+    dir = Services.dirsvc.get("ProfD", Ci.nsIFile);
+    if (path.startsWith(dir.path))
+      return AddonManager.SCOPE_PROFILE;
+
+    // Plugins anywhere else in the user's home are in the user scope,
+    // but not all platforms have a home directory.
+    try {
+      dir = Services.dirsvc.get("Home", Ci.nsIFile);
+      if (path.startsWith(dir.path))
+        return AddonManager.SCOPE_USER;
+    } catch (e) {
+      if (!e.result || e.result != Components.results.NS_ERROR_FAILURE)
+        throw e;
+      // Do nothing: missing "Home".
+    }
+
+    // Any other locations are system scope
+    return AddonManager.SCOPE_SYSTEM;
+  },
+
+  get pendingOperations() {
+    return AddonManager.PENDING_NONE;
+  },
+
+  get operationsRequiringRestart() {
+    return AddonManager.OP_NEEDS_RESTART_NONE;
+  },
+
+  get permissions() {
+    let { tags: [tag] } = pluginFor(this);
+    let permissions = 0;
+    if (tag.isEnabledStateLocked) {
+      return permissions;
+    }
+    if (!this.appDisabled) {
+
+      if (this.userDisabled !== true)
+        permissions |= AddonManager.PERM_CAN_DISABLE;
+
+      let blocklistState = this.blocklistState;
+      let isCTPBlocklisted =
+        (blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE ||
+         blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE);
+
+      if (this.userDisabled !== AddonManager.STATE_ASK_TO_ACTIVATE &&
+          (Services.prefs.getBoolPref("plugins.click_to_play") ||
+           isCTPBlocklisted)) {
+        permissions |= AddonManager.PERM_CAN_ASK_TO_ACTIVATE;
+      }
+
+      if (this.userDisabled !== false && !isCTPBlocklisted) {
+        permissions |= AddonManager.PERM_CAN_ENABLE;
+      }
+    }
+    return permissions;
+  },
+
+  get optionsType() {
+    if (canDisableFlashProtectedMode(this)) {
+      return AddonManager.OPTIONS_TYPE_INLINE;
+    }
+    return AddonManager.OPTIONS_TYPE_INLINE_INFO;
+  },
+
+  get optionsURL() {
+    return "chrome://mozapps/content/extensions/pluginPrefs.xul";
+  },
+
+  get updateDate() {
+    return this.installDate;
+  },
+
+  get isCompatible() {
+    return true;
+  },
+
+  get isPlatformCompatible() {
+    return true;
+  },
+
+  get providesUpdatesSecurely() {
+    return true;
+  },
+
+  get foreignInstall() {
+    return true;
+  },
+
+  isCompatibleWith: function(aAppVersion, aPlatformVersion) {
+    return true;
+  },
+
+  findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) {
+    if ("onNoCompatibilityUpdateAvailable" in aListener)
+      aListener.onNoCompatibilityUpdateAvailable(this);
+    if ("onNoUpdateAvailable" in aListener)
+      aListener.onNoUpdateAvailable(this);
+    if ("onUpdateFinished" in aListener)
+      aListener.onUpdateFinished(this);
+  }
+};
+
+AddonManagerPrivate.registerProvider(PluginProvider, [
+  new AddonManagerPrivate.AddonType("plugin", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 6000,
+                                    AddonManager.TYPE_SUPPORTS_ASK_TO_ACTIVATE)
+]);
diff --git a/toolkit/mozapps/webextensions/internal/ProductAddonChecker.jsm b/toolkit/mozapps/webextensions/internal/ProductAddonChecker.jsm
new file mode 100644
index 000000000..f98dd2a94
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/ProductAddonChecker.jsm
@@ -0,0 +1,467 @@
+/* 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 { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+
+const LOCAL_EME_SOURCES = [{
+  "id": "gmp-eme-adobe",
+  "src": "chrome://global/content/gmp-sources/eme-adobe.json"
+}, {
+  "id": "gmp-gmpopenh264",
+  "src": "chrome://global/content/gmp-sources/openh264.json"
+}, {
+  "id": "gmp-widevinecdm",
+  "src": "chrome://global/content/gmp-sources/widevinecdm.json"
+}];
+
+this.EXPORTED_SYMBOLS = [ "ProductAddonChecker" ];
+
+Cu.importGlobalProperties(["XMLHttpRequest"]);
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/Log.jsm");
+Cu.import("resource://gre/modules/CertUtils.jsm");
+/* globals checkCert, BadCertHandler*/
+Cu.import("resource://gre/modules/FileUtils.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+
+/* globals GMPPrefs */
+XPCOMUtils.defineLazyModuleGetter(this, "GMPPrefs",
+                                  "resource://gre/modules/GMPUtils.jsm");
+
+/* globals OS */
+
+XPCOMUtils.defineLazyModuleGetter(this, "UpdateUtils",
+                                  "resource://gre/modules/UpdateUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest",
+                                  "resource://gre/modules/ServiceRequest.jsm");
+
+// This exists so that tests can override the XHR behaviour for downloading
+// the addon update XML file.
+var CreateXHR = function() {
+  return Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
+  createInstance(Ci.nsISupports);
+}
+
+var logger = Log.repository.getLogger("addons.productaddons");
+
+/**
+ * Number of milliseconds after which we need to cancel `downloadXML`.
+ *
+ * Bug 1087674 suggests that the XHR we use in `downloadXML` may
+ * never terminate in presence of network nuisances (e.g. strange
+ * antivirus behavior). This timeout is a defensive measure to ensure
+ * that we fail cleanly in such case.
+ */
+const TIMEOUT_DELAY_MS = 20000;
+// Chunk size for the incremental downloader
+const DOWNLOAD_CHUNK_BYTES_SIZE = 300000;
+// Incremental downloader interval
+const DOWNLOAD_INTERVAL  = 0;
+// How much of a file to read into memory at a time for hashing
+const HASH_CHUNK_SIZE = 8192;
+
+/**
+ * Gets the status of an XMLHttpRequest either directly or from its underlying
+ * channel.
+ *
+ * @param  request
+ *         The XMLHttpRequest.
+ * @return an integer status value.
+ */
+function getRequestStatus(request) {
+  let status = null;
+  try {
+    status = request.status;
+  }
+  catch (e) {
+  }
+
+  if (status != null) {
+    return status;
+  }
+
+  return request.channel.QueryInterface(Ci.nsIRequest).status;
+}
+
+/**
+ * Downloads an XML document from a URL optionally testing the SSL certificate
+ * for certain attributes.
+ *
+ * @param  url
+ *         The url to download from.
+ * @param  allowNonBuiltIn
+ *         Whether to trust SSL certificates without a built-in CA issuer.
+ * @param  allowedCerts
+ *         The list of certificate attributes to match the SSL certificate
+ *         against or null to skip checks.
+ * @return a promise that resolves to the DOM document downloaded or rejects
+ *         with a JS exception in case of error.
+ */
+function downloadXML(url, allowNonBuiltIn = false, allowedCerts = null) {
+  return new Promise((resolve, reject) => {
+    let request = CreateXHR();
+    // This is here to let unit test code override XHR
+    if (request.wrappedJSObject) {
+      request = request.wrappedJSObject;
+    }
+    request.open("GET", url, true);
+    request.channel.notificationCallbacks = new BadCertHandler(allowNonBuiltIn);
+    // Prevent the request from reading from the cache.
+    request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE;
+    // Prevent the request from writing to the cache.
+    request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING;
+    // Use conservative TLS settings. See bug 1325501.
+    // TODO move to ServiceRequest.
+    if (request.channel instanceof Ci.nsIHttpChannelInternal) {
+      request.channel.QueryInterface(Ci.nsIHttpChannelInternal).beConservative = true;
+    }
+    request.timeout = TIMEOUT_DELAY_MS;
+
+    request.overrideMimeType("text/xml");
+    // The Cache-Control header is only interpreted by proxies and the
+    // final destination. It does not help if a resource is already
+    // cached locally.
+    request.setRequestHeader("Cache-Control", "no-cache");
+    // HTTP/1.0 servers might not implement Cache-Control and
+    // might only implement Pragma: no-cache
+    request.setRequestHeader("Pragma", "no-cache");
+
+    let fail = (event) => {
+      let request = event.target;
+      let status = getRequestStatus(request);
+      let message = "Failed downloading XML, status: " + status +  ", reason: " + event.type;
+      logger.warn(message);
+      let ex = new Error(message);
+      ex.status = status;
+      reject(ex);
+    };
+
+    let success = (event) => {
+      logger.info("Completed downloading document");
+      let request = event.target;
+
+      try {
+        checkCert(request.channel, allowNonBuiltIn, allowedCerts);
+      } catch (ex) {
+        logger.error("Request failed certificate checks: " + ex);
+        ex.status = getRequestStatus(request);
+        reject(ex);
+        return;
+      }
+
+      resolve(request.responseXML);
+    };
+
+    request.addEventListener("error", fail, false);
+    request.addEventListener("abort", fail, false);
+    request.addEventListener("timeout", fail, false);
+    request.addEventListener("load", success, false);
+
+    logger.info("sending request to: " + url);
+    request.send(null);
+  });
+}
+
+function downloadJSON(uri) {
+  logger.info("fetching config from: " + uri);
+  return new Promise((resolve, reject) => {
+    let xmlHttp = new ServiceRequest({mozAnon: true});
+
+    xmlHttp.onload = function(aResponse) {
+      resolve(JSON.parse(this.responseText));
+    };
+
+    xmlHttp.onerror = function(e) {
+      reject("Fetching " + uri + " results in error code: " + e.target.status);
+    };
+
+    xmlHttp.open("GET", uri);
+    xmlHttp.overrideMimeType("application/json");
+    xmlHttp.send();
+  });
+}
+
+
+/**
+ * Parses a list of add-ons from a DOM document.
+ *
+ * @param  document
+ *         The DOM document to parse.
+ * @return null if there is no <addons> element otherwise an object containing
+ *         an array of the addons listed and a field notifying whether the
+ *         fallback was used.
+ */
+function parseXML(document) {
+  // Check that the root element is correct
+  if (document.documentElement.localName != "updates") {
+    throw new Error("got node name: " + document.documentElement.localName +
+                    ", expected: updates");
+  }
+
+  // Check if there are any addons elements in the updates element
+  let addons = document.querySelector("updates:root > addons");
+  if (!addons) {
+    return null;
+  }
+
+  let results = [];
+  let addonList = document.querySelectorAll("updates:root > addons > addon");
+  for (let addonElement of addonList) {
+    let addon = {};
+
+    for (let name of ["id", "URL", "hashFunction", "hashValue", "version", "size"]) {
+      if (addonElement.hasAttribute(name)) {
+        addon[name] = addonElement.getAttribute(name);
+      }
+    }
+    addon.size = Number(addon.size) || undefined;
+
+    results.push(addon);
+  }
+
+  return {
+    usedFallback: false,
+    gmpAddons: results
+  };
+}
+
+/**
+ * If downloading from the network fails (AUS server is down),
+ * load the sources from local build configuration.
+ */
+function downloadLocalConfig() {
+
+  if (!GMPPrefs.get(GMPPrefs.KEY_UPDATE_ENABLED, true)) {
+    logger.info("Updates are disabled via media.gmp-manager.updateEnabled");
+    return Promise.resolve({usedFallback: true, gmpAddons: []});
+  }
+
+  return Promise.all(LOCAL_EME_SOURCES.map(conf => {
+    return downloadJSON(conf.src).then(addons => {
+
+      let platforms = addons.vendors[conf.id].platforms;
+      let target = Services.appinfo.OS + "_" + UpdateUtils.ABI;
+      let details = null;
+
+      while (!details) {
+        if (!(target in platforms)) {
+          // There was no matching platform so return false, this addon
+          // will be filtered from the results below
+          logger.info("no details found for: " + target);
+          return false;
+        }
+        // Field either has the details of the binary or is an alias
+        // to another build target key that does
+        if (platforms[target].alias) {
+          target = platforms[target].alias;
+        } else {
+          details = platforms[target];
+        }
+      }
+
+      logger.info("found plugin: " + conf.id);
+      return {
+        "id": conf.id,
+        "URL": details.fileUrl,
+        "hashFunction": addons.hashFunction,
+        "hashValue": details.hashValue,
+        "version": addons.vendors[conf.id].version,
+        "size": details.filesize
+      };
+    });
+  })).then(addons => {
+
+    // Some filters may not match this platform so
+    // filter those out
+    addons = addons.filter(x => x !== false);
+
+    return {
+      usedFallback: true,
+      gmpAddons: addons
+    };
+  });
+}
+
+/**
+ * Downloads file from a URL using XHR.
+ *
+ * @param  url
+ *         The url to download from.
+ * @return a promise that resolves to the path of a temporary file or rejects
+ *         with a JS exception in case of error.
+ */
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    let xhr = new XMLHttpRequest();
+    xhr.onload = function(response) {
+      logger.info("downloadXHR File download. status=" + xhr.status);
+      if (xhr.status != 200 && xhr.status != 206) {
+        reject(Components.Exception("File download failed", xhr.status));
+        return;
+      }
+      Task.spawn(function* () {
+        let f = yield OS.File.openUnique(OS.Path.join(OS.Constants.Path.tmpDir, "tmpaddon"));
+        let path = f.path;
+        logger.info(`Downloaded file will be saved to ${path}`);
+        yield f.file.close();
+        yield OS.File.writeAtomic(path, new Uint8Array(xhr.response));
+        return path;
+      }).then(resolve, reject);
+    };
+
+    let fail = (event) => {
+      let request = event.target;
+      let status = getRequestStatus(request);
+      let message = "Failed downloading via XHR, status: " + status +  ", reason: " + event.type;
+      logger.warn(message);
+      let ex = new Error(message);
+      ex.status = status;
+      reject(ex);
+    };
+    xhr.addEventListener("error", fail);
+    xhr.addEventListener("abort", fail);
+
+    xhr.responseType = "arraybuffer";
+    try {
+      xhr.open("GET", url);
+      // Use conservative TLS settings. See bug 1325501.
+      // TODO move to ServiceRequest.
+      if (xhr.channel instanceof Ci.nsIHttpChannelInternal) {
+        xhr.channel.QueryInterface(Ci.nsIHttpChannelInternal).beConservative = true;
+      }
+      xhr.send(null);
+    } catch (ex) {
+      reject(ex);
+    }
+  });
+}
+
+/**
+ * Convert a string containing binary values to hex.
+ */
+function binaryToHex(input) {
+  let result = "";
+  for (let i = 0; i < input.length; ++i) {
+    let hex = input.charCodeAt(i).toString(16);
+    if (hex.length == 1) {
+      hex = "0" + hex;
+    }
+    result += hex;
+  }
+  return result;
+}
+
+/**
+ * Calculates the hash of a file.
+ *
+ * @param  hashFunction
+ *         The type of hash function to use, must be supported by nsICryptoHash.
+ * @param  path
+ *         The path of the file to hash.
+ * @return a promise that resolves to hash of the file or rejects with a JS
+ *         exception in case of error.
+ */
+var computeHash = Task.async(function*(hashFunction, path) {
+  let file = yield OS.File.open(path, { existing: true, read: true });
+  try {
+    let hasher = Cc["@mozilla.org/security/hash;1"].
+                 createInstance(Ci.nsICryptoHash);
+    hasher.initWithString(hashFunction);
+
+    let bytes;
+    do {
+      bytes = yield file.read(HASH_CHUNK_SIZE);
+      hasher.update(bytes, bytes.length);
+    } while (bytes.length == HASH_CHUNK_SIZE);
+
+    return binaryToHex(hasher.finish(false));
+  }
+  finally {
+    yield file.close();
+  }
+});
+
+/**
+ * Verifies that a downloaded file matches what was expected.
+ *
+ * @param  properties
+ *         The properties to check, `size` and `hashFunction` with `hashValue`
+ *         are supported. Any properties missing won't be checked.
+ * @param  path
+ *         The path of the file to check.
+ * @return a promise that resolves if the file matched or rejects with a JS
+ *         exception in case of error.
+ */
+var verifyFile = Task.async(function*(properties, path) {
+  if (properties.size !== undefined) {
+    let stat = yield OS.File.stat(path);
+    if (stat.size != properties.size) {
+      throw new Error("Downloaded file was " + stat.size + " bytes but expected " + properties.size + " bytes.");
+    }
+  }
+
+  if (properties.hashFunction !== undefined) {
+    let expectedDigest = properties.hashValue.toLowerCase();
+    let digest = yield computeHash(properties.hashFunction, path);
+    if (digest != expectedDigest) {
+      throw new Error("Hash was `" + digest + "` but expected `" + expectedDigest +  "`.");
+    }
+  }
+});
+
+const ProductAddonChecker = {
+  /**
+   * Downloads a list of add-ons from a URL optionally testing the SSL
+   * certificate for certain attributes.
+   *
+   * @param  url
+   *         The url to download from.
+   * @param  allowNonBuiltIn
+   *         Whether to trust SSL certificates without a built-in CA issuer.
+   * @param  allowedCerts
+   *         The list of certificate attributes to match the SSL certificate
+   *         against or null to skip checks.
+   * @return a promise that resolves to an object containing the list of add-ons
+   *         and whether the local fallback was used, or rejects with a JS
+   *         exception in case of error.
+   */
+  getProductAddonList: function(url, allowNonBuiltIn = false, allowedCerts = null) {
+    if (!GMPPrefs.get(GMPPrefs.KEY_UPDATE_ENABLED, true)) {
+      logger.info("Updates are disabled via media.gmp-manager.updateEnabled");
+      return Promise.resolve({usedFallback: true, gmpAddons: []});
+    }
+
+    return downloadXML(url, allowNonBuiltIn, allowedCerts)
+      .then(parseXML)
+      .catch(downloadLocalConfig);
+  },
+
+  /**
+   * Downloads an add-on to a local file and checks that it matches the expected
+   * file. The caller is responsible for deleting the temporary file returned.
+   *
+   * @param  addon
+   *         The addon to download.
+   * @return a promise that resolves to the temporary file downloaded or rejects
+   *         with a JS exception in case of error.
+   */
+  downloadAddon: Task.async(function*(addon) {
+    let path = yield downloadFile(addon.URL);
+    try {
+      yield verifyFile(addon, path);
+      return path;
+    }
+    catch (e) {
+      yield OS.File.remove(path);
+      throw e;
+    }
+  })
+}
diff --git a/toolkit/mozapps/webextensions/internal/SpellCheckDictionaryBootstrap.js b/toolkit/mozapps/webextensions/internal/SpellCheckDictionaryBootstrap.js
new file mode 100644
index 000000000..f4f557fc2
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/SpellCheckDictionaryBootstrap.js
@@ -0,0 +1,17 @@
+/* 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/. */
+
+var hunspell, dir;
+
+function startup(data) {
+  hunspell = Components.classes["@mozilla.org/spellchecker/engine;1"]
+                       .getService(Components.interfaces.mozISpellCheckingEngine);
+  dir = data.installPath.clone();
+  dir.append("dictionaries");
+  hunspell.addDirectory(dir);
+}
+
+function shutdown() {
+  hunspell.removeDirectory(dir);
+}
diff --git a/toolkit/mozapps/webextensions/internal/WebExtensionBootstrap.js b/toolkit/mozapps/webextensions/internal/WebExtensionBootstrap.js
new file mode 100644
index 000000000..a920c2eae
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/WebExtensionBootstrap.js
@@ -0,0 +1,39 @@
+/* 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";
+
+Components.utils.import("resource://gre/modules/Extension.jsm");
+
+var extension;
+
+const BOOTSTRAP_REASON_TO_STRING_MAP = {
+  1: "APP_STARTUP",
+  2: "APP_SHUTDOWN",
+  3: "ADDON_ENABLE",
+  4: "ADDON_DISABLE",
+  5: "ADDON_INSTALL",
+  6: "ADDON_UNINSTALL",
+  7: "ADDON_UPGRADE",
+  8: "ADDON_DOWNGRADE",
+}
+
+function install(data, reason)
+{
+}
+
+function startup(data, reason)
+{
+  extension = new Extension(data, BOOTSTRAP_REASON_TO_STRING_MAP[reason]);
+  extension.startup();
+}
+
+function shutdown(data, reason)
+{
+  extension.shutdown();
+}
+
+function uninstall(data, reason)
+{
+}
diff --git a/toolkit/mozapps/webextensions/internal/XPIProvider.jsm b/toolkit/mozapps/webextensions/internal/XPIProvider.jsm
new file mode 100644
index 000000000..87e09cef1
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/XPIProvider.jsm
@@ -0,0 +1,9305 @@
+ /* 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"];
+
+const CONSTANTS = {};
+Cu.import("resource://gre/modules/addons/AddonConstants.jsm", CONSTANTS);
+const { ADDON_SIGNING, REQUIRE_SIGNING } = CONSTANTS
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/AddonManager.jsm");
+Cu.import("resource://gre/modules/Preferences.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, "ExtensionData",
+                                  "resource://gre/modules/Extension.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ExtensionManagement",
+                                  "resource://gre/modules/ExtensionManagement.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Locale",
+                                  "resource://gre/modules/Locale.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://devtools/client/framework/ToolboxProcess.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ConsoleAPI",
+                                  "resource://gre/modules/Console.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ProductAddonChecker",
+                                  "resource://gre/modules/addons/ProductAddonChecker.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "UpdateUtils",
+                                  "resource://gre/modules/UpdateUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AppConstants",
+                                  "resource://gre/modules/AppConstants.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "isAddonPartOfE10SRollout",
+                                  "resource://gre/modules/addons/E10SAddonsRollout.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "LegacyExtensionsUtils",
+                                  "resource://gre/modules/LegacyExtensionsUtils.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "Blocklist",
+                                   "@mozilla.org/extensions/blocklist;1",
+                                   Ci.nsIBlocklistService);
+XPCOMUtils.defineLazyServiceGetter(this,
+                                   "ChromeRegistry",
+                                   "@mozilla.org/chrome/chrome-registry;1",
+                                   "nsIChromeRegistry");
+XPCOMUtils.defineLazyServiceGetter(this,
+                                   "ResProtocolHandler",
+                                   "@mozilla.org/network/protocol;1?name=resource",
+                                   "nsIResProtocolHandler");
+XPCOMUtils.defineLazyServiceGetter(this,
+                                   "AddonPolicyService",
+                                   "@mozilla.org/addons/policy-service;1",
+                                   "nsIAddonPolicyService");
+XPCOMUtils.defineLazyServiceGetter(this,
+                                   "AddonPathService",
+                                   "@mozilla.org/addon-path-service;1",
+                                   "amIAddonPathService");
+
+XPCOMUtils.defineLazyGetter(this, "CertUtils", function() {
+  let certUtils = {};
+  Components.utils.import("resource://gre/modules/CertUtils.jsm", certUtils);
+  return certUtils;
+});
+
+Cu.importGlobalProperties(["URL"]);
+
+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_XPI_STATE                  = "extensions.xpiState";
+const PREF_BOOTSTRAP_ADDONS           = "extensions.bootstrappedAddons";
+const PREF_PENDING_OPERATIONS         = "extensions.pendingOperations";
+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_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";
+// xpinstall.signatures.required only supported in dev builds
+const PREF_XPI_SIGNATURES_REQUIRED    = "xpinstall.signatures.required";
+const PREF_XPI_SIGNATURES_DEV_ROOT    = "xpinstall.signatures.dev-root";
+const PREF_XPI_PERMISSIONS_BRANCH     = "xpinstall.";
+const PREF_XPI_UNPACK                 = "extensions.alwaysUnpack";
+const PREF_INSTALL_REQUIREBUILTINCERTS = "extensions.install.requireBuiltInCerts";
+const PREF_INSTALL_REQUIRESECUREORIGIN = "extensions.install.requireSecureOrigin";
+const PREF_INSTALL_DISTRO_ADDONS      = "extensions.installDistroAddons";
+const PREF_BRANCH_INSTALLED_ADDON     = "extensions.installedDistroAddon.";
+const PREF_INTERPOSITION_ENABLED      = "extensions.interposition.enabled";
+const PREF_SYSTEM_ADDON_SET           = "extensions.systemAddonSet";
+const PREF_SYSTEM_ADDON_UPDATE_URL    = "extensions.systemAddon.update.url";
+const PREF_E10S_BLOCK_ENABLE          = "extensions.e10sBlocksEnabling";
+const PREF_E10S_ADDON_BLOCKLIST       = "extensions.e10s.rollout.blocklist";
+const PREF_E10S_ADDON_POLICY          = "extensions.e10s.rollout.policy";
+const PREF_E10S_HAS_NONEXEMPT_ADDON   = "extensions.e10s.rollout.hasAddon";
+
+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 PREF_EM_HOTFIX_ID               = "extensions.hotfix.id";
+const PREF_EM_CERT_CHECKATTRIBUTES    = "extensions.hotfix.cert.checkAttributes";
+const PREF_EM_HOTFIX_CERTS            = "extensions.hotfix.certs.";
+
+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_SYSTEM_ADDONS               = "features";
+const DIR_STAGE                       = "staged";
+const DIR_TRASH                       = "trash";
+
+const FILE_DATABASE                   = "extensions.json";
+const FILE_OLD_CACHE                  = "extensions.cache";
+const FILE_RDF_MANIFEST               = "install.rdf";
+const FILE_WEB_MANIFEST               = "manifest.json";
+const FILE_XPI_ADDONS_LIST            = "extensions.ini";
+
+const KEY_PROFILEDIR                  = "ProfD";
+const KEY_ADDON_APP_DIR               = "XREAddonAppDir";
+const KEY_TEMPDIR                     = "TmpD";
+const KEY_APP_DISTRIBUTION            = "XREAppDist";
+const KEY_APP_FEATURES                = "XREAppFeat";
+
+const KEY_APP_PROFILE                 = "app-profile";
+const KEY_APP_SYSTEM_ADDONS           = "app-system-addons";
+const KEY_APP_SYSTEM_DEFAULTS         = "app-system-defaults";
+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 KEY_APP_TEMPORARY               = "app-temporary";
+
+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";
+
+const XPI_SIGNATURE_CHECK_PERIOD      = 24 * 60 * 60;
+
+XPCOMUtils.defineConstant(this, "DB_SCHEMA", 19);
+
+const NOTIFICATION_TOOLBOXPROCESS_LOADED      = "ToolboxProcessLoaded";
+
+// 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 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: Blocklist.STATE_BLOCKED,
+    blockID: "i162" },
+  { creator: "Mozilla.org",
+    level: Blocklist.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,
+};
+
+if (!AppConstants.RELEASE_OR_BETA)
+  TYPES.apiextension = 256;
+
+// Some add-on types that we track internally are presented as other types
+// externally
+const TYPE_ALIASES = {
+  "webextension": "extension",
+  "apiextension": "extension",
+};
+
+const CHROME_TYPES = new Set([
+  "extension",
+  "locale",
+  "experiment",
+]);
+
+const RESTARTLESS_TYPES = new Set([
+  "webextension",
+  "dictionary",
+  "experiment",
+  "locale",
+  "apiextension",
+]);
+
+const SIGNED_TYPES = new Set([
+  "webextension",
+  "extension",
+  "experiment",
+  "apiextension",
+]);
+
+// This is a random number array that can be used as "salt" when generating
+// an automatic ID based on the directory path of an add-on. It will prevent
+// someone from creating an ID for a permanent add-on that could be replaced
+// by a temporary add-on (because that would be confusing, I guess).
+const TEMP_INSTALL_ID_GEN_SESSION =
+  new Uint8Array(Float64Array.of(Math.random()).buffer);
+
+// Whether add-on signing is required.
+function mustSign(aType) {
+  if (!SIGNED_TYPES.has(aType))
+    return false;
+  return REQUIRE_SIGNING || Preferences.get(PREF_XPI_SIGNATURES_REQUIRED, false);
+}
+
+// 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";
+const MSG_MESSAGE_MANAGER_CACHES_FLUSH = "AddonMessageManagerCachesFlush";
+
+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)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+const LAZY_OBJECTS = ["XPIDatabase", "XPIDatabaseReconcile"];
+/* globals XPIDatabase, XPIDatabaseReconcile*/
+
+var gLazyObjectsLoaded = false;
+
+function loadLazyObjects() {
+  let uri = "resource://gre/modules/addons/XPIProviderUtils.js";
+  let scope = Cu.Sandbox(Services.scriptSecurityManager.getSystemPrincipal(), {
+    sandboxName: uri,
+    wantGlobalProperties: ["TextDecoder"],
+  });
+
+  let shared = {
+    ADDON_SIGNING,
+    SIGNED_TYPES,
+    BOOTSTRAP_REASONS,
+    DB_SCHEMA,
+    AddonInternal,
+    XPIProvider,
+    XPIStates,
+    syncLoadManifestFromFile,
+    isUsableAddon,
+    recordAddonTelemetry,
+    applyBlocklistChanges,
+    flushChromeCaches,
+    canRunInSafeMode,
+  }
+
+  for (let key of Object.keys(shared))
+    scope[key] = shared[key];
+
+  Services.scriptloader.loadSubScript(uri, scope);
+
+  for (let name of LAZY_OBJECTS) {
+    delete gGlobalScope[name];
+    gGlobalScope[name] = scope[name];
+  }
+  gLazyObjectsLoaded = true;
+  return scope;
+}
+
+LAZY_OBJECTS.forEach(name => {
+  Object.defineProperty(gGlobalScope, name, {
+    get: function() {
+      let objs = loadLazyObjects();
+      return objs[name];
+    },
+    configurable: true
+  });
+});
+
+
+// Behaves like Promise.all except waits for all promises to resolve/reject
+// before resolving/rejecting itself
+function waitForAllPromises(promises) {
+  return new Promise((resolve, reject) => {
+    let shouldReject = false;
+    let rejectValue = null;
+
+    let newPromises = promises.map(
+      p => p.catch(value => {
+        shouldReject = true;
+        rejectValue = value;
+      })
+    );
+    Promise.all(newPromises)
+           .then((results) => shouldReject ? reject(rejectValue) : resolve(results));
+  });
+}
+
+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;
+}
+
+/**
+ * Converts an iterable of addon objects into a map with the add-on's ID as key.
+ */
+function addonMap(addons) {
+  return new Map(addons.map(a => [a.id, a]));
+}
+
+/**
+ * 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);
+  }
+}
+
+/**
+ * Write a given string to a file
+ *
+ * @param  file
+ *         The nsIFile instance to write into
+ * @param  string
+ *         The string to write
+ */
+function writeStringToFile(file, string) {
+  let stream = Cc["@mozilla.org/network/file-output-stream;1"].
+               createInstance(Ci.nsIFileOutputStream);
+  let converter = Cc["@mozilla.org/intl/converter-output-stream;1"].
+                  createInstance(Ci.nsIConverterOutputStream);
+
+  try {
+    stream.init(file, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
+                            FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE,
+                           0);
+    converter.init(stream, "UTF-8", 0, 0x0000);
+    converter.writeString(string);
+  }
+  finally {
+    converter.close();
+    stream.close();
+  }
+}
+
+/**
+ * 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(aFile, aTargetDirectory, aCopy) {
+    let oldFile = aCopy ? null : aFile.clone();
+    let newFile = aFile.clone();
+    try {
+      if (aCopy) {
+        newFile.copyTo(aTargetDirectory, null);
+        // copyTo does not update the nsIFile with the new.
+        newFile = aTargetDirectory.clone();
+        newFile.append(aFile.leafName);
+        // Windows roaming profiles won't properly sync directories if a new file
+        // has an older lastModifiedTime than a previous file, so update.
+        newFile.lastModifiedTime = Date.now();
+      }
+      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(aDirectory, aTargetDirectory, aCopy) {
+    if (aDirectory.contains(aTargetDirectory)) {
+      let err = new Error(`Not installing ${aDirectory} into its own descendent ${aTargetDirectory}`);
+      logger.error(err);
+      throw err;
+    }
+
+    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);
+    for (let entry of entries) {
+      try {
+        this._installDirEntry(entry, newDir, aCopy);
+      }
+      catch (e) {
+        logger.error("Failed to " + (aCopy ? "copy" : "move") + " entry " +
+                     entry.path, e);
+        throw e;
+      }
+    }
+
+    // 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(aDirEntry, aTargetDirectory, aCopy) {
+    let isDir = null;
+
+    try {
+      isDir = aDirEntry.isDirectory() && !aDirEntry.isSymlink();
+    }
+    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.
+   */
+  moveUnder: function(aFile, aTargetDirectory) {
+    try {
+      this._installDirEntry(aFile, aTargetDirectory, false);
+    }
+    catch (e) {
+      this.rollback();
+      throw e;
+    }
+  },
+
+  /**
+   * Renames a file to a new location.  If an error occurs then all
+   * files that have been moved will be moved back to their original location.
+   *
+   * @param  aOldLocation
+   *         The old location of the file.
+   * @param  aNewLocation
+   *         The new location of the file.
+   */
+  moveTo: function(aOldLocation, aNewLocation) {
+    try {
+      let oldFile = aOldLocation.clone(), newFile = aNewLocation.clone();
+      oldFile.moveTo(newFile.parent, newFile.leafName);
+      this._installedFiles.push({ oldFile: oldFile, newFile: newFile, isMoveTo: true});
+    }
+    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(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() {
+    while (this._installedFiles.length > 0) {
+      let move = this._installedFiles.pop();
+      if (move.isMoveTo) {
+        move.newFile.moveTo(move.oldDir.parent, move.oldDir.leafName);
+      }
+      else if (move.newFile.isDirectory() && !move.newFile.isSymlink()) {
+        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());
+  }
+};
+
+/**
+ * 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 oldBlocklistState = Blocklist.getAddonBlocklistState(aOldAddon.wrapper,
+                                                           aOldAppVersion,
+                                                           aOldPlatformVersion);
+  let newBlocklistState = Blocklist.getAddonBlocklistState(aNewAddon.wrapper);
+
+  // If the blocklist state hasn't changed then the properties don't need to
+  // change
+  if (newBlocklistState == oldBlocklistState)
+    return;
+
+  if (newBlocklistState == Blocklist.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;
+  }
+}
+
+/**
+ * Evaluates whether an add-on is allowed to run in safe mode.
+ *
+ * @param  aAddon
+ *         The add-on to check
+ * @return true if the add-on should run in safe mode
+ */
+function canRunInSafeMode(aAddon) {
+  // Even though the updated system add-ons aren't generally run in safe mode we
+  // include them here so their uninstall functions get called when switching
+  // back to the default set.
+
+  // TODO product should make the call about temporary add-ons running
+  // in safe mode. assuming for now that they are.
+  if (aAddon._installLocation.name == KEY_APP_TEMPORARY)
+    return true;
+
+  return aAddon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS ||
+         aAddon._installLocation.name == KEY_APP_SYSTEM_ADDONS;
+}
+
+/**
+ * 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 (mustSign(aAddon.type) && !aAddon.isCorrectlySigned) {
+    logger.warn(`Add-on ${aAddon.id} is not correctly signed.`);
+    return false;
+  }
+
+  if (aAddon.blocklistState == Blocklist.STATE_BLOCKED) {
+    logger.warn(`Add-on ${aAddon.id} is blocklisted.`);
+    return false;
+  }
+
+  // Experiments are installed through an external mechanism that
+  // limits target audience to compatible clients. We trust it knows what
+  // it's doing and skip compatibility checks.
+  //
+  // This decision does forfeit defense in depth. If the experiments system
+  // is ever wrong about targeting an add-on to a specific application
+  // or platform, the client will likely see errors.
+  if (aAddon.type == "experiment")
+    return true;
+
+  if (AddonManager.checkUpdateSecurity && !aAddon.providesUpdatesSecurely) {
+    logger.warn(`Updates for add-on ${aAddon.id} must be provided over HTTPS.`);
+    return false;
+  }
+
+
+  if (!aAddon.isPlatformCompatible) {
+    logger.warn(`Add-on ${aAddon.id} is not compatible with platform.`);
+    return false;
+  }
+
+  if (aAddon.dependencies.length) {
+    let isActive = id => {
+      let active = XPIProvider.activeAddons.get(id);
+      return active && !active.disable;
+    };
+
+    if (aAddon.dependencies.some(id => !isActive(id)))
+      return false;
+  }
+
+  if (AddonManager.checkCompatibility) {
+    if (!aAddon.isCompatible) {
+      logger.warn(`Add-on ${aAddon.id} is not compatible with application version.`);
+      return false;
+    }
+  }
+  else {
+    let app = aAddon.matchingTargetApplication;
+    if (!app) {
+      logger.warn(`Add-on ${aAddon.id} is not compatible with target application.`);
+      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) {
+          logger.warn(`Theme ${aAddon.id} is not compatible with application version.`);
+          return false;
+        }
+      } catch (e) {}
+    }
+  }
+
+  return true;
+}
+
+XPCOMUtils.defineLazyServiceGetter(this, "gRDF", "@mozilla.org/rdf/rdf-service;1",
+                                   Ci.nsIRDFService);
+
+function EM_R(aProperty) {
+  return gRDF.GetResource(PREFIX_NS_EM + aProperty);
+}
+
+function createAddonDetails(id, aAddon) {
+  return {
+    id: id || aAddon.id,
+    type: aAddon.type,
+    version: aAddon.version,
+    multiprocessCompatible: aAddon.multiprocessCompatible,
+    mpcOptedOut: aAddon.mpcOptedOut,
+    runInSafeMode: aAddon.runInSafeMode,
+    dependencies: aAddon.dependencies,
+    hasEmbeddedWebExtension: aAddon.hasEmbeddedWebExtension,
+  };
+}
+
+/**
+ * Converts an internal add-on type to the type presented through the API.
+ *
+ * @param  aType
+ *         The internal add-on type
+ * @return an external add-on type
+ */
+function getExternalType(aType) {
+  if (aType in TYPE_ALIASES)
+    return TYPE_ALIASES[aType];
+  return aType;
+}
+
+function getManifestFileForDir(aDir) {
+  let file = aDir.clone();
+  file.append(FILE_RDF_MANIFEST);
+  if (file.exists() && file.isFile())
+    return file;
+  file.leafName = FILE_WEB_MANIFEST;
+  if (file.exists() && file.isFile())
+    return file;
+  return null;
+}
+
+function getManifestEntryForZipReader(aZipReader) {
+  if (aZipReader.hasEntry(FILE_RDF_MANIFEST))
+    return FILE_RDF_MANIFEST;
+  if (aZipReader.hasEntry(FILE_WEB_MANIFEST))
+    return FILE_WEB_MANIFEST;
+  return null;
+}
+
+/**
+ * Converts a list of API types to a list of API types and any aliases for those
+ * types.
+ *
+ * @param  aTypes
+ *         An array of types or null for all types
+ * @return an array of types or null for all types
+ */
+function getAllAliasesForTypes(aTypes) {
+  if (!aTypes)
+    return null;
+
+  // Build a set of all requested types and their aliases
+  let typeset = new Set(aTypes);
+
+  for (let alias of Object.keys(TYPE_ALIASES)) {
+    // Ignore any requested internal types
+    typeset.delete(alias);
+
+    // Add any alias for the internal type
+    if (typeset.has(TYPE_ALIASES[alias]))
+      typeset.add(alias);
+  }
+
+  return [...typeset];
+}
+
+/**
+ * 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 a manifest stream.
+ *
+ * @param  aUri
+ *         A |file:| or |jar:| URL for the manifest
+ * @return an AddonInternal object
+ * @throws if the install manifest in the stream is corrupt or could not
+ *         be read
+ */
+var loadManifestFromWebManifest = Task.async(function*(aUri) {
+  // We're passed the URI for the manifest file. Get the URI for its
+  // parent directory.
+  let uri = NetUtil.newURI("./", null, aUri);
+
+  let extension = new ExtensionData(uri);
+
+  let manifest = yield extension.readManifest();
+
+  // Read the list of available locales, and pre-load messages for
+  // all locales.
+  let locales = yield extension.initAllLocales();
+
+  // If there were any errors loading the extension, bail out now.
+  if (extension.errors.length)
+    throw new Error("Extension is invalid");
+
+  let bss = (manifest.browser_specific_settings && manifest.browser_specific_settings.gecko)
+      || (manifest.applications && manifest.applications.gecko) || {};
+  if (manifest.browser_specific_settings && manifest.applications) {
+    logger.warn("Ignoring applications property in manifest");
+  }
+
+  // A * is illegal in strict_min_version
+  if (bss.strict_min_version && bss.strict_min_version.split(".").some(part => part == "*")) {
+    throw new Error("The use of '*' in strict_min_version is invalid");
+  }
+
+  let addon = new AddonInternal();
+  addon.id = bss.id;
+  addon.version = manifest.version;
+  addon.type = "webextension";
+  addon.unpack = false;
+  addon.strictCompatibility = true;
+  addon.bootstrap = true;
+  addon.hasBinaryComponents = false;
+  addon.multiprocessCompatible = true;
+  addon.internalName = null;
+  addon.updateURL = bss.update_url;
+  addon.updateKey = null;
+  addon.optionsURL = null;
+  addon.optionsType = null;
+  addon.aboutURL = null;
+  addon.dependencies = Object.freeze(Array.from(extension.dependencies));
+
+  if (manifest.options_ui) {
+    // Store just the relative path here, the AddonWrapper getURL
+    // wrapper maps this to a full URL.
+    addon.optionsURL = manifest.options_ui.page;
+    if (manifest.options_ui.open_in_tab)
+      addon.optionsType = AddonManager.OPTIONS_TYPE_TAB;
+    else
+      addon.optionsType = AddonManager.OPTIONS_TYPE_INLINE_BROWSER;
+  }
+
+  // WebExtensions don't use iconURLs
+  addon.iconURL = null;
+  addon.icon64URL = null;
+  addon.icons = manifest.icons || {};
+
+  addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT;
+
+  function getLocale(aLocale) {
+    // Use the raw manifest, here, since we need values with their
+    // localization placeholders still in place.
+    let rawManifest = extension.rawManifest;
+
+    // As a convenience, allow author to be set if its a string bug 1313567.
+    let creator = typeof(rawManifest.author) === 'string' ? rawManifest.author : null;
+    let homepageURL = rawManifest.homepage_url;
+
+    // Allow developer to override creator and homepage_url.
+    if (rawManifest.developer) {
+      if (rawManifest.developer.name) {
+        creator = rawManifest.developer.name;
+      }
+      if (rawManifest.developer.url) {
+        homepageURL = rawManifest.developer.url;
+      }
+    }
+
+    let result = {
+      name: extension.localize(rawManifest.name, aLocale),
+      description: extension.localize(rawManifest.description, aLocale),
+      creator: extension.localize(creator, aLocale),
+      homepageURL: extension.localize(homepageURL, aLocale),
+
+      developers: null,
+      translators: null,
+      contributors: null,
+      locales: [aLocale],
+    };
+    return result;
+  }
+
+  addon.defaultLocale = getLocale(extension.defaultLocale);
+  addon.locales = Array.from(locales.keys(), getLocale);
+
+  delete addon.defaultLocale.locales;
+
+  addon.targetApplications = [{
+    id: TOOLKIT_ID,
+    minVersion: bss.strict_min_version,
+    maxVersion: bss.strict_max_version,
+  }];
+
+  addon.targetPlatforms = [];
+  addon.userDisabled = false;
+  addon.softDisabled = addon.blocklistState == Blocklist.STATE_SOFTBLOCKED;
+
+  return addon;
+});
+
+/**
+ * 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
+ */
+let loadManifestFromRDF = Task.async(function*(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;
+      }
+    }
+
+    for (let prop of PROP_LOCALE_SINGLE) {
+      locale[prop] = getRDFProperty(aDs, aSource, prop);
+    }
+
+    for (let prop of PROP_LOCALE_MULTI) {
+      // Don't store empty arrays
+      let props = getPropertyArray(aDs, aSource,
+                                   prop.substring(0, prop.length - 1));
+      if (props.length > 0)
+        locale[prop] = 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();
+  for (let prop of PROP_METADATA) {
+    addon[prop] = getRDFProperty(ds, root, prop);
+  }
+  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 these properties for extensions.
+  if (addon.type == "extension") {
+    addon.bootstrap = getRDFProperty(ds, root, "bootstrap") == "true";
+
+    let mpcValue = getRDFProperty(ds, root, "multiprocessCompatible");
+    addon.multiprocessCompatible = mpcValue == "true";
+    addon.mpcOptedOut = mpcValue == "false";
+
+    addon.hasEmbeddedWebExtension = getRDFProperty(ds, root, "hasEmbeddedWebExtension") == "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);
+    }
+
+    if (addon.hasEmbeddedWebExtension) {
+      let uri = NetUtil.newURI("webextension/manifest.json", null, aUri);
+      let embeddedAddon = yield loadManifestFromWebManifest(uri);
+      if (embeddedAddon.optionsURL) {
+        if (addon.optionsType || addon.optionsURL)
+          logger.warn(`Addon ${addon.id} specifies optionsType or optionsURL ` +
+                      `in both install.rdf and manifest.json`);
+
+        addon.optionsURL = embeddedAddon.optionsURL;
+        addon.optionsType = embeddedAddon.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 dependencies = new Set();
+  targets = ds.GetTargets(root, EM_R("dependency"), true);
+  while (targets.hasMoreElements()) {
+    let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
+    let id = getRDFProperty(ds, target, "id");
+    dependencies.add(id);
+  }
+  addon.dependencies = Object.freeze(Array.from(dependencies));
+
+  let seenApplications = [];
+  addon.targetApplications = [];
+  targets = ds.GetTargets(root, EM_R("targetApplication"), true);
+  while (targets.hasMoreElements()) {
+    let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
+    let targetAppInfo = {};
+    for (let prop of PROP_TARGETAPP) {
+      targetAppInfo[prop] = getRDFProperty(ds, target, prop);
+    }
+    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 = [];
+  for (let targetPlatform of targetPlatforms) {
+    let platform = {
+      os: null,
+      abi: null
+    };
+
+    let pos = targetPlatform.indexOf("_");
+    if (pos != -1) {
+      platform.os = targetPlatform.substring(0, pos);
+      platform.abi = targetPlatform.substring(pos + 1);
+    }
+    else {
+      platform.os = targetPlatform;
+    }
+
+    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;
+  }
+  else if (addon.type == "experiment") {
+    // Experiments are disabled by default. It is up to the Experiments Manager
+    // to enable them (it drives installation).
+    addon.userDisabled = true;
+  }
+  else {
+    addon.userDisabled = false;
+  }
+
+  addon.softDisabled = addon.blocklistState == Blocklist.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;
+  }
+
+  // icons will be filled by the calling function
+  addon.icons = {};
+
+  return addon;
+});
+
+function defineSyncGUID(aAddon) {
+  // Define .syncGUID as a lazy property which is also settable
+  Object.defineProperty(aAddon, "syncGUID", {
+    get: () => {
+      // Generate random GUID used for Sync.
+      let guid = Cc["@mozilla.org/uuid-generator;1"]
+          .getService(Ci.nsIUUIDGenerator)
+          .generateUUID().toString();
+
+      delete aAddon.syncGUID;
+      aAddon.syncGUID = guid;
+      return guid;
+    },
+    set: (val) => {
+      delete aAddon.syncGUID;
+      aAddon.syncGUID = val;
+    },
+    configurable: true,
+    enumerable: true,
+  });
+}
+
+// Generate a unique ID based on the path to this temporary add-on location.
+function generateTemporaryInstallID(aFile) {
+  const hasher = Cc["@mozilla.org/security/hash;1"]
+        .createInstance(Ci.nsICryptoHash);
+  hasher.init(hasher.SHA1);
+  const data = new TextEncoder().encode(aFile.path);
+  // Make it so this ID cannot be guessed.
+  const sess = TEMP_INSTALL_ID_GEN_SESSION;
+  hasher.update(sess, sess.length);
+  hasher.update(data, data.length);
+  let id = `${getHashStringForCrypto(hasher)}@temporary-addon`;
+  logger.info(`Generated temp id ${id} (${sess.join("")}) for ${aFile.path}`);
+  return id;
+}
+
+/**
+ * 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
+ */
+var loadManifestFromDir = Task.async(function*(aDir, aInstallLocation) {
+  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;
+  }
+
+  function* loadFromRDF(aUri) {
+    let fis = Cc["@mozilla.org/network/file-input-stream;1"].
+              createInstance(Ci.nsIFileInputStream);
+    fis.init(aUri.file, -1, -1, false);
+    let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
+              createInstance(Ci.nsIBufferedInputStream);
+    bis.init(fis, 4096);
+    try {
+      var addon = yield loadManifestFromRDF(aUri, bis);
+    } finally {
+      bis.close();
+      fis.close();
+    }
+
+    let iconFile = aDir.clone();
+    iconFile.append("icon.png");
+
+    if (iconFile.exists()) {
+      addon.icons[32] = "icon.png";
+      addon.icons[48] = "icon.png";
+    }
+
+    let icon64File = aDir.clone();
+    icon64File.append("icon64.png");
+
+    if (icon64File.exists()) {
+      addon.icons[64] = "icon64.png";
+    }
+
+    let file = aDir.clone();
+    file.append("chrome.manifest");
+    let chromeManifest = ChromeManifestParser.parseSync(Services.io.newFileURI(file));
+    addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
+                                                             "binary-component");
+    return addon;
+  }
+
+  let file = getManifestFileForDir(aDir);
+  if (!file) {
+    throw new Error("Directory " + aDir.path + " does not contain a valid " +
+                    "install manifest");
+  }
+
+  let uri = Services.io.newFileURI(file).QueryInterface(Ci.nsIFileURL);
+
+  let addon;
+  if (file.leafName == FILE_WEB_MANIFEST) {
+    addon = yield loadManifestFromWebManifest(uri);
+    if (!addon.id) {
+      if (aInstallLocation == TemporaryInstallLocation) {
+        addon.id = generateTemporaryInstallID(aDir);
+      } else {
+        addon.id = aDir.leafName;
+      }
+    }
+  } else {
+    addon = yield loadFromRDF(uri);
+  }
+
+  addon._sourceBundle = aDir.clone();
+  addon._installLocation = aInstallLocation;
+  addon.size = getFileSize(aDir);
+  addon.signedState = yield verifyDirSignedState(aDir, addon)
+    .then(({signedState}) => signedState);
+  addon.appDisabled = !isUsableAddon(addon);
+
+  defineSyncGUID(addon);
+
+  return addon;
+});
+
+/**
+ * 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
+ */
+var loadManifestFromZipReader = Task.async(function*(aZipReader, aInstallLocation) {
+  function* loadFromRDF(aUri) {
+    let zis = aZipReader.getInputStream(entry);
+    let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
+              createInstance(Ci.nsIBufferedInputStream);
+    bis.init(zis, 4096);
+    try {
+      var addon = yield loadManifestFromRDF(aUri, bis);
+    } finally {
+      bis.close();
+      zis.close();
+    }
+
+    if (aZipReader.hasEntry("icon.png")) {
+      addon.icons[32] = "icon.png";
+      addon.icons[48] = "icon.png";
+    }
+
+    if (aZipReader.hasEntry("icon64.png")) {
+      addon.icons[64] = "icon64.png";
+    }
+
+    // Binary components can only be loaded from unpacked addons.
+    if (addon.unpack) {
+      let uri = buildJarURI(aZipReader.file, "chrome.manifest");
+      let chromeManifest = ChromeManifestParser.parseSync(uri);
+      addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
+                                                               "binary-component");
+    } else {
+      addon.hasBinaryComponents = false;
+    }
+
+    return addon;
+  }
+
+  let entry = getManifestEntryForZipReader(aZipReader);
+  if (!entry) {
+    throw new Error("File " + aZipReader.file.path + " does not contain a valid " +
+                    "install manifest");
+  }
+
+  let uri = buildJarURI(aZipReader.file, entry);
+
+  let isWebExtension = (entry == FILE_WEB_MANIFEST);
+
+  let addon = isWebExtension ?
+              yield loadManifestFromWebManifest(uri) :
+              yield loadFromRDF(uri);
+
+  addon._sourceBundle = aZipReader.file;
+  addon._installLocation = aInstallLocation;
+
+  addon.size = 0;
+  let entries = aZipReader.findEntries(null);
+  while (entries.hasMore())
+    addon.size += aZipReader.getEntry(entries.getNext()).realSize;
+
+  let {signedState, cert} = yield verifyZipSignedState(aZipReader.file, addon);
+  addon.signedState = signedState;
+  if (isWebExtension && !addon.id) {
+    if (cert) {
+      addon.id = cert.commonName;
+      if (!gIDTest.test(addon.id)) {
+        throw new Error(`Webextension is signed with an invalid id (${addon.id})`);
+      }
+    }
+    if (!addon.id && aInstallLocation == TemporaryInstallLocation) {
+      addon.id = generateTemporaryInstallID(aZipReader.file);
+    }
+  }
+  addon.appDisabled = !isUsableAddon(addon);
+
+  defineSyncGUID(addon);
+
+  return addon;
+});
+
+/**
+ * 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
+ */
+var loadManifestFromZipFile = Task.async(function*(aXPIFile, aInstallLocation) {
+  let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
+                  createInstance(Ci.nsIZipReader);
+  try {
+    zipReader.open(aXPIFile);
+
+    // Can't return this promise because that will make us close the zip reader
+    // before it has finished loading the manifest. Wait for the result and then
+    // return.
+    let manifest = yield loadManifestFromZipReader(zipReader, aInstallLocation);
+    return manifest;
+  }
+  finally {
+    zipReader.close();
+  }
+});
+
+function loadManifestFromFile(aFile, aInstallLocation) {
+  if (aFile.isFile())
+    return loadManifestFromZipFile(aFile, aInstallLocation);
+  return loadManifestFromDir(aFile, aInstallLocation);
+}
+
+/**
+ * A synchronous method for loading an add-on's manifest. This should only ever
+ * be used during startup or a sync load of the add-ons DB
+ */
+function syncLoadManifestFromFile(aFile, aInstallLocation) {
+  let success = undefined;
+  let result = null;
+
+  loadManifestFromFile(aFile, aInstallLocation).then(val => {
+    success = true;
+    result = val;
+  }, val => {
+    success = false;
+    result = val
+  });
+
+  let thread = Services.tm.currentThread;
+
+  while (success === undefined)
+    thread.processNextEvent(true);
+
+  if (!success)
+    throw result;
+  return result;
+}
+
+/**
+ * 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(part => resource.append(part));
+
+    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);
+  Services.mm.broadcastAsyncMessage(MSG_JAR_FLUSH, aJarFile.path);
+}
+
+function flushChromeCaches() {
+  // Init this, so it will get the notification.
+  Services.obs.notifyObservers(null, "startupcache-invalidate", null);
+  // Flush message manager cached scripts
+  Services.obs.notifyObservers(null, "message-manager-flush-caches", null);
+  // Also dispatch this event to child processes
+  Services.mm.broadcastAsyncMessage(MSG_MESSAGE_MANAGER_CACHES_FLUSH, 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  aCertificate
+ *         The nsIX509Cert to compare against
+ * @return true if all the contents that should be signed were signed by the
+ *         principal
+ */
+function verifyZipSigning(aZip, aCertificate) {
+  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 entryCertificate = aZip.getSigningCert(entry);
+    if (!entryCertificate || !aCertificate.equals(entryCertificate)) {
+      return false;
+    }
+  }
+  return aZip.manifestEntriesCount == count;
+}
+
+/**
+ * Returns the signedState for a given return code and certificate by verifying
+ * it against the expected ID.
+ */
+function getSignedStatus(aRv, aCert, aAddonID) {
+  let expectedCommonName = aAddonID;
+  if (aAddonID && aAddonID.length > 64) {
+    let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+                    createInstance(Ci.nsIScriptableUnicodeConverter);
+    converter.charset = "UTF-8";
+    let data = converter.convertToByteArray(aAddonID, {});
+
+    let crypto = Cc["@mozilla.org/security/hash;1"].
+                 createInstance(Ci.nsICryptoHash);
+    crypto.init(Ci.nsICryptoHash.SHA256);
+    crypto.update(data, data.length);
+    expectedCommonName = getHashStringForCrypto(crypto);
+  }
+
+  switch (aRv) {
+    case Cr.NS_OK:
+      if (expectedCommonName && expectedCommonName != aCert.commonName)
+        return AddonManager.SIGNEDSTATE_BROKEN;
+
+      let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined);
+      if (hotfixID && hotfixID == aAddonID && Preferences.get(PREF_EM_CERT_CHECKATTRIBUTES, false)) {
+        // The hotfix add-on has some more rigorous certificate checks
+        try {
+          CertUtils.validateCert(aCert,
+                                 CertUtils.readCertPrefs(PREF_EM_HOTFIX_CERTS));
+        }
+        catch (e) {
+          logger.warn("The hotfix add-on was not signed by the expected " +
+                      "certificate and so will not be installed.", e);
+          return AddonManager.SIGNEDSTATE_BROKEN;
+        }
+      }
+
+      if (aCert.organizationalUnit == "Mozilla Components")
+        return AddonManager.SIGNEDSTATE_SYSTEM;
+
+      return /preliminary/i.test(aCert.organizationalUnit)
+               ? AddonManager.SIGNEDSTATE_PRELIMINARY
+               : AddonManager.SIGNEDSTATE_SIGNED;
+    case Cr.NS_ERROR_SIGNED_JAR_NOT_SIGNED:
+      return AddonManager.SIGNEDSTATE_MISSING;
+    case Cr.NS_ERROR_SIGNED_JAR_MANIFEST_INVALID:
+    case Cr.NS_ERROR_SIGNED_JAR_ENTRY_INVALID:
+    case Cr.NS_ERROR_SIGNED_JAR_ENTRY_MISSING:
+    case Cr.NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE:
+    case Cr.NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY:
+    case Cr.NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY:
+      return AddonManager.SIGNEDSTATE_BROKEN;
+    default:
+      // Any other error indicates that either the add-on isn't signed or it
+      // is signed by a signature that doesn't chain to the trusted root.
+      return AddonManager.SIGNEDSTATE_UNKNOWN;
+  }
+}
+
+function shouldVerifySignedState(aAddon) {
+  // Updated system add-ons should always have their signature checked
+  if (aAddon._installLocation.name == KEY_APP_SYSTEM_ADDONS)
+    return true;
+
+  // We don't care about signatures for default system add-ons
+  if (aAddon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS)
+    return false;
+
+  // Hotfixes should always have their signature checked
+  let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined);
+  if (hotfixID && aAddon.id == hotfixID)
+    return true;
+
+  // Otherwise only check signatures if signing is enabled and the add-on is one
+  // of the signed types.
+  return ADDON_SIGNING && SIGNED_TYPES.has(aAddon.type);
+}
+
+let gCertDB = Cc["@mozilla.org/security/x509certdb;1"]
+              .getService(Ci.nsIX509CertDB);
+
+/**
+ * Verifies that a zip file's contents are all correctly signed by an
+ * AMO-issued certificate
+ *
+ * @param  aFile
+ *         the xpi file to check
+ * @param  aAddon
+ *         the add-on object to verify
+ * @return a Promise that resolves to an object with properties:
+ *         signedState: an AddonManager.SIGNEDSTATE_* constant
+ *         cert: an nsIX509Cert
+ */
+function verifyZipSignedState(aFile, aAddon) {
+  if (!shouldVerifySignedState(aAddon))
+    return Promise.resolve({
+      signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED,
+      cert: null
+    });
+
+  let root = Ci.nsIX509CertDB.AddonsPublicRoot;
+  if (!REQUIRE_SIGNING && Preferences.get(PREF_XPI_SIGNATURES_DEV_ROOT, false))
+    root = Ci.nsIX509CertDB.AddonsStageRoot;
+
+  return new Promise(resolve => {
+    let callback = {
+      openSignedAppFileFinished: function(aRv, aZipReader, aCert) {
+        if (aZipReader)
+          aZipReader.close();
+        resolve({
+          signedState: getSignedStatus(aRv, aCert, aAddon.id),
+          cert: aCert
+        });
+      }
+    };
+    // This allows the certificate DB to get the raw JS callback object so the
+    // test code can pass through objects that XPConnect would reject.
+    callback.wrappedJSObject = callback;
+
+    gCertDB.openSignedAppFileAsync(root, aFile, callback);
+  });
+}
+
+/**
+ * Verifies that a directory's contents are all correctly signed by an
+ * AMO-issued certificate
+ *
+ * @param  aDir
+ *         the directory to check
+ * @param  aAddon
+ *         the add-on object to verify
+ * @return a Promise that resolves to an object with properties:
+ *         signedState: an AddonManager.SIGNEDSTATE_* constant
+ *         cert: an nsIX509Cert
+ */
+function verifyDirSignedState(aDir, aAddon) {
+  if (!shouldVerifySignedState(aAddon))
+    return Promise.resolve({
+      signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED,
+      cert: null,
+    });
+
+  let root = Ci.nsIX509CertDB.AddonsPublicRoot;
+  if (!REQUIRE_SIGNING && Preferences.get(PREF_XPI_SIGNATURES_DEV_ROOT, false))
+    root = Ci.nsIX509CertDB.AddonsStageRoot;
+
+  return new Promise(resolve => {
+    let callback = {
+      verifySignedDirectoryFinished: function(aRv, aCert) {
+        resolve({
+          signedState: getSignedStatus(aRv, aCert, aAddon.id),
+          cert: null,
+        });
+      }
+    };
+    // This allows the certificate DB to get the raw JS callback object so the
+    // test code can pass through objects that XPConnect would reject.
+    callback.wrappedJSObject = callback;
+
+    gCertDB.verifySignedDirectoryAsync(root, aDir, callback);
+  });
+}
+
+/**
+ * Verifies that a bundle's contents are all correctly signed by an
+ * AMO-issued certificate
+ *
+ * @param  aBundle
+ *         the nsIFile for the bundle to check, either a directory or zip file
+ * @param  aAddon
+ *         the add-on object to verify
+ * @return a Promise that resolves to an AddonManager.SIGNEDSTATE_* constant.
+ */
+function verifyBundleSignedState(aBundle, aAddon) {
+  let promise = aBundle.isFile() ? verifyZipSignedState(aBundle, aAddon)
+      : verifyDirSignedState(aBundle, aAddon);
+  return promise.then(({signedState}) => signedState);
+}
+
+/**
+ * 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)
+        throw e;
+      // 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() || aFile.isSymlink()) {
+      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(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();
+    }
+  }
+}
+
+/**
+ * Record a bit of per-addon telemetry
+ * @param aAddon the addon to record
+ */
+function recordAddonTelemetry(aAddon) {
+  let locale = aAddon.defaultLocale;
+  if (locale) {
+    if (locale.name)
+      XPIProvider.setTelemetry(aAddon.id, "name", locale.name);
+    if (locale.creator)
+      XPIProvider.setTelemetry(aAddon.id, "creator", locale.creator);
+  }
+}
+
+/**
+ * The on-disk state of an individual XPI, created from an Object
+ * as stored in the 'extensions.xpiState' pref.
+ */
+function XPIState(saved) {
+  for (let [short, long] of XPIState.prototype.fields) {
+    if (short in saved) {
+      this[long] = saved[short];
+    }
+  }
+}
+
+XPIState.prototype = {
+  fields: [['d', 'descriptor'],
+           ['e', 'enabled'],
+           ['v', 'version'],
+           ['st', 'scanTime'],
+           ['mt', 'manifestTime']],
+  /**
+   * Return the last modified time, based on enabled/disabled
+   */
+  get mtime() {
+    if (!this.enabled && ('manifestTime' in this) && this.manifestTime > this.scanTime) {
+      return this.manifestTime;
+    }
+    return this.scanTime;
+  },
+
+  toJSON() {
+    let json = {};
+    for (let [short, long] of XPIState.prototype.fields) {
+      if (long in this) {
+        json[short] = this[long];
+      }
+    }
+    return json;
+  },
+
+  /**
+   * Update the last modified time for an add-on on disk.
+   * @param aFile: nsIFile path of the add-on.
+   * @param aId: The add-on ID.
+   * @return True if the time stamp has changed.
+   */
+  getModTime(aFile, aId) {
+    let changed = false;
+    let scanStarted = Cu.now();
+    // For an unknown or enabled add-on, we do a full recursive scan.
+    if (!('scanTime' in this) || this.enabled) {
+      logger.debug('getModTime: Recursive scan of ' + aId);
+      let [modFile, modTime, items] = recursiveLastModifiedTime(aFile);
+      XPIProvider._mostRecentlyModifiedFile[aId] = modFile;
+      XPIProvider.setTelemetry(aId, "scan_items", items);
+      if (modTime != this.scanTime) {
+        this.scanTime = modTime;
+        changed = true;
+      }
+    }
+    // if the add-on is disabled, modified time is the install manifest time, if
+    // any. If no manifest exists, we assume this is a packed .xpi and use
+    // the time stamp of {path}
+    try {
+      // Get the install manifest update time, if any.
+      let maniFile = getManifestFileForDir(aFile);
+      if (!(aId in XPIProvider._mostRecentlyModifiedFile)) {
+        XPIProvider._mostRecentlyModifiedFile[aId] = maniFile.leafName;
+      }
+      let maniTime = maniFile.lastModifiedTime;
+      if (maniTime != this.manifestTime) {
+        this.manifestTime = maniTime;
+        changed = true;
+      }
+    } catch (e) {
+      // No manifest
+      delete this.manifestTime;
+      try {
+        let dtime = aFile.lastModifiedTime;
+        if (dtime != this.scanTime) {
+          changed = true;
+          this.scanTime = dtime;
+        }
+      } catch (e) {
+        logger.warn("Can't get modified time of ${file}: ${e}", {file: aFile.path, e: e});
+        changed = true;
+        this.scanTime = 0;
+      }
+    }
+    // Record duration of file-modified check
+    XPIProvider.setTelemetry(aId, "scan_MS", Math.round(Cu.now() - scanStarted));
+
+    return changed;
+  },
+
+  /**
+   * Update the XPIState to match an XPIDatabase entry; if 'enabled' is changed to true,
+   * update the last-modified time. This should probably be made async, but for now we
+   * don't want to maintain parallel sync and async versions of the scan.
+   * Caller is responsible for doing XPIStates.save() if necessary.
+   * @param aDBAddon The DBAddonInternal for this add-on.
+   * @param aUpdated The add-on was updated, so we must record new modified time.
+   */
+  syncWithDB(aDBAddon, aUpdated = false) {
+    logger.debug("Updating XPIState for " + JSON.stringify(aDBAddon));
+    // If the add-on changes from disabled to enabled, we should re-check the modified time.
+    // If this is a newly found add-on, it won't have an 'enabled' field but we
+    // did a full recursive scan in that case, so we don't need to do it again.
+    // We don't use aDBAddon.active here because it's not updated until after restart.
+    let mustGetMod = (aDBAddon.visible && !aDBAddon.disabled && !this.enabled);
+    this.enabled = (aDBAddon.visible && !aDBAddon.disabled);
+    this.version = aDBAddon.version;
+    // XXX Eventually also copy bootstrap, etc.
+    if (aUpdated || mustGetMod) {
+      this.getModTime(new nsIFile(this.descriptor), aDBAddon.id);
+      if (this.scanTime != aDBAddon.updateDate) {
+        aDBAddon.updateDate = this.scanTime;
+        XPIDatabase.saveChanges();
+      }
+    }
+  },
+};
+
+// Constructor for an ES6 Map that knows how to convert itself into a
+// regular object for toJSON().
+function SerializableMap() {
+  let m = new Map();
+  m.toJSON = function() {
+    let out = {}
+    for (let [key, val] of m) {
+      out[key] = val;
+    }
+    return out;
+  };
+  return m;
+}
+
+/**
+ * Keeps track of the state of XPI add-ons on the file system.
+ */
+this.XPIStates = {
+  // Map(location name -> Map(add-on ID -> XPIState))
+  db: null,
+
+  get size() {
+    if (!this.db) {
+      return 0;
+    }
+    let count = 0;
+    for (let location of this.db.values()) {
+      count += location.size;
+    }
+    return count;
+  },
+
+  /**
+   * Load extension state data from preferences.
+   */
+  loadExtensionState() {
+    let state = {};
+
+    // Clear out old directory state cache.
+    Preferences.reset(PREF_INSTALL_CACHE);
+
+    let cache = Preferences.get(PREF_XPI_STATE, "{}");
+    try {
+      state = JSON.parse(cache);
+    } catch (e) {
+      logger.warn("Error parsing extensions.xpiState ${state}: ${error}",
+          {state: cache, error: e});
+    }
+    logger.debug("Loaded add-on state from prefs: ${}", state);
+    return state;
+  },
+
+  /**
+   * Walk through all install locations, highest priority first,
+   * comparing the on-disk state of extensions to what is stored in prefs.
+   * @return true if anything has changed.
+   */
+  getInstallState() {
+    let oldState = this.loadExtensionState();
+    let changed = false;
+    this.db = new SerializableMap();
+
+    for (let location of XPIProvider.installLocations) {
+      // The list of add-on like file/directory names in the install location.
+      let addons = location.getAddonLocations();
+      // The results of scanning this location.
+      let foundAddons = new SerializableMap();
+
+      // What our old state thinks should be in this location.
+      let locState = {};
+      if (location.name in oldState) {
+        locState = oldState[location.name];
+        // We've seen this location.
+        delete oldState[location.name];
+      }
+
+      for (let [id, file] of addons) {
+        if (!(id in locState)) {
+          logger.debug("New add-on ${id} in ${location}", {id: id, location: location.name});
+          let xpiState = new XPIState({d: file.persistentDescriptor});
+          changed = xpiState.getModTime(file, id) || changed;
+          foundAddons.set(id, xpiState);
+        } else {
+          let xpiState = new XPIState(locState[id]);
+          // We found this add-on in the file system
+          delete locState[id];
+
+          changed = xpiState.getModTime(file, id) || changed;
+
+          if (file.persistentDescriptor != xpiState.descriptor) {
+            xpiState.descriptor = file.persistentDescriptor;
+            changed = true;
+          }
+          if (changed) {
+            logger.debug("Changed add-on ${id} in ${location}", {id: id, location: location.name});
+          }
+          else {
+            logger.debug("Existing add-on ${id} in ${location}", {id: id, location: location.name});
+          }
+          foundAddons.set(id, xpiState);
+        }
+        XPIProvider.setTelemetry(id, "location", location.name);
+      }
+
+      // Anything left behind in oldState was removed from the file system.
+      for (let id in locState) {
+        changed = true;
+        break;
+      }
+      // If we found anything, add this location to our database.
+      if (foundAddons.size != 0) {
+        this.db.set(location.name, foundAddons);
+      }
+    }
+
+    // If there's anything left in oldState, an install location that held add-ons
+    // was removed from the browser configuration.
+    for (let location in oldState) {
+      changed = true;
+      break;
+    }
+
+    logger.debug("getInstallState changed: ${rv}, state: ${state}",
+        {rv: changed, state: this.db});
+    return changed;
+  },
+
+  /**
+   * Get the Map of XPI states for a particular location.
+   * @param aLocation The name of the install location.
+   * @return Map (id -> XPIState) or null if there are no add-ons in the location.
+   */
+  getLocation(aLocation) {
+    return this.db.get(aLocation);
+  },
+
+  /**
+   * Get the XPI state for a specific add-on in a location.
+   * If the state is not in our cache, return null.
+   * @param aLocation The name of the location where the add-on is installed.
+   * @param aId       The add-on ID
+   * @return The XPIState entry for the add-on, or null.
+   */
+  getAddon(aLocation, aId) {
+    let location = this.db.get(aLocation);
+    if (!location) {
+      return null;
+    }
+    return location.get(aId);
+  },
+
+  /**
+   * Find the highest priority location of an add-on by ID and return the
+   * location and the XPIState.
+   * @param aId   The add-on ID
+   * @return [locationName, XPIState] if the add-on is found, [undefined, undefined]
+   *         if the add-on is not found.
+   */
+  findAddon(aId) {
+    // Fortunately the Map iterator returns in order of insertion, which is
+    // also our highest -> lowest priority order.
+    for (let [name, location] of this.db) {
+      if (location.has(aId)) {
+        return [name, location.get(aId)];
+      }
+    }
+    return [undefined, undefined];
+  },
+
+  /**
+   * Add a new XPIState for an add-on and synchronize it with the DBAddonInternal.
+   * @param aAddon DBAddonInternal for the new add-on.
+   */
+  addAddon(aAddon) {
+    let location = this.db.get(aAddon.location);
+    if (!location) {
+      // First add-on in this location.
+      location = new SerializableMap();
+      this.db.set(aAddon.location, location);
+    }
+    logger.debug("XPIStates adding add-on ${id} in ${location}: ${descriptor}", aAddon);
+    let xpiState = new XPIState({d: aAddon.descriptor});
+    location.set(aAddon.id, xpiState);
+    xpiState.syncWithDB(aAddon, true);
+    XPIProvider.setTelemetry(aAddon.id, "location", aAddon.location);
+  },
+
+  /**
+   * Save the current state of installed add-ons.
+   * XXX this *totally* should be a .json file using DeferredSave...
+   */
+  save() {
+    let cache = JSON.stringify(this.db);
+    Services.prefs.setCharPref(PREF_XPI_STATE, cache);
+  },
+
+  /**
+   * Remove the XPIState for an add-on and save the new state.
+   * @param aLocation  The name of the add-on location.
+   * @param aId        The ID of the add-on.
+   */
+  removeAddon(aLocation, aId) {
+    logger.debug("Removing XPIState for " + aLocation + ":" + aId);
+    let location = this.db.get(aLocation);
+    if (!location) {
+      return;
+    }
+    location.delete(aId);
+    if (location.size == 0) {
+      this.db.delete(aLocation);
+    }
+    this.save();
+  },
+};
+
+this.XPIProvider = {
+  get name() {
+    return "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 Map of active addons to their bootstrapScope by ID
+  activeAddons: new Map(),
+  // True if the platform could have activated extensions
+  extensionsActive: false,
+  // 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,
+  // 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: {},
+  // A Map from an add-on install to its ID
+  _addonFileMap: new Map(),
+  // Flag to know if ToolboxProcess.jsm has already been loaded by someone or not
+  _toolboxProcessLoaded: false,
+  // Have we started shutting down bootstrap add-ons?
+  _closing: false,
+
+  /**
+   * Returns an array of the add-on values in `bootstrappedAddons`,
+   * sorted so that all of an add-on's dependencies appear in the array
+   * before itself.
+   *
+   * @returns {Array<object>}
+   *   A sorted array of add-on objects. Each value is a copy of the
+   *   corresponding value in the `bootstrappedAddons` object, with an
+   *   additional `id` property, which corresponds to the key in that
+   *   object, which is the same as the add-ons ID.
+   */
+  sortBootstrappedAddons: function() {
+    let addons = {};
+
+    // Sort the list of IDs so that the ordering is deterministic.
+    for (let id of Object.keys(this.bootstrappedAddons).sort()) {
+      addons[id] = Object.assign({id}, this.bootstrappedAddons[id]);
+    }
+
+    let res = new Set();
+    let seen = new Set();
+
+    let add = addon => {
+      seen.add(addon.id);
+
+      for (let id of addon.dependencies || []) {
+        if (id in addons && !seen.has(id)) {
+          add(addons[id]);
+        }
+      }
+
+      res.add(addon.id);
+    }
+
+    Object.values(addons).forEach(add);
+
+    return Array.from(res, id => addons[id]);
+  },
+
+  /*
+   * Set a value in the telemetry hash for a given ID
+   */
+  setTelemetry: function(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: [],
+
+  doing: function(aCancellable) {
+    this._inProgress.push(aCancellable);
+  },
+
+  done: function(aCancellable) {
+    let i = this._inProgress.indexOf(aCancellable);
+    if (i != -1) {
+      this._inProgress.splice(i, 1);
+      return true;
+    }
+    return false;
+  },
+
+  cancelAll: function() {
+    // Cancelling one may alter _inProgress, so don't use a simple iterator
+    while (this._inProgress.length > 0) {
+      let c = this._inProgress.shift();
+      try {
+        c.cancel();
+      }
+      catch (e) {
+        logger.warn("Cancel failed", e);
+      }
+    }
+  },
+
+  /**
+   * 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(aID, aFile) {
+    logger.info("Mapping " + aID + " to " + aFile.path);
+    this._addonFileMap.set(aID, aFile.path);
+
+    AddonPathService.insertPath(aFile.path, aID);
+  },
+
+  /**
+   * 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(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 = NetUtil.newChannel({
+            uri: aURI,
+            loadUsingSystemPrincipal: true
+          });
+        }
+        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(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 = aLocked ? new DirectoryInstallLocation(aName, dir, aScope)
+                               : new MutableDirectoryInstallLocation(aName, dir, aScope);
+      }
+      catch (e) {
+        logger.warn("Failed to add directory install location " + aName, e);
+        return;
+      }
+
+      XPIProvider.installLocations.push(location);
+      XPIProvider.installLocationsByName[location.name] = location;
+    }
+
+    function addSystemAddonInstallLocation(aName, aKey, aPaths, aScope) {
+      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 SystemAddonInstallLocation(aName, dir, aScope, aAppChanged !== false);
+      }
+      catch (e) {
+        logger.warn("Failed to add system add-on 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 = new Set();
+      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 = {};
+      // Register our details structure with AddonManager
+      AddonManagerPrivate.setTelemetryDetails("XPI", this._telemetryDetails);
+
+      let hasRegistry = ("nsIWindowsRegKey" in Ci);
+
+      let enabledScopes = Preferences.get(PREF_EM_ENABLED_SCOPES,
+                                          AddonManager.SCOPE_ALL);
+
+      // These must be in order of priority, highest to lowest,
+      // for processFileChanges etc. to work
+
+      XPIProvider.installLocations.push(TemporaryInstallLocation);
+      XPIProvider.installLocationsByName[TemporaryInstallLocation.name] =
+        TemporaryInstallLocation;
+
+      // The profile location is always enabled
+      addDirectoryInstallLocation(KEY_APP_PROFILE, KEY_PROFILEDIR,
+                                  [DIR_EXTENSIONS],
+                                  AddonManager.SCOPE_PROFILE, false);
+
+      addSystemAddonInstallLocation(KEY_APP_SYSTEM_ADDONS, KEY_PROFILEDIR,
+                                    [DIR_SYSTEM_ADDONS],
+                                    AddonManager.SCOPE_PROFILE);
+
+      addDirectoryInstallLocation(KEY_APP_SYSTEM_DEFAULTS, KEY_APP_FEATURES,
+                                  [], AddonManager.SCOPE_PROFILE, true);
+
+      if (enabledScopes & AddonManager.SCOPE_USER) {
+        addDirectoryInstallLocation(KEY_APP_SYSTEM_USER, "XREUSysExt",
+                                    [Services.appinfo.ID],
+                                    AddonManager.SCOPE_USER, true);
+        if (hasRegistry) {
+          addRegistryInstallLocation("winreg-app-user",
+                                     Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+                                     AddonManager.SCOPE_USER);
+        }
+      }
+
+      addDirectoryInstallLocation(KEY_APP_GLOBAL, KEY_ADDON_APP_DIR,
+                                  [DIR_EXTENSIONS],
+                                  AddonManager.SCOPE_APPLICATION, true);
+
+      if (enabledScopes & AddonManager.SCOPE_SYSTEM) {
+        addDirectoryInstallLocation(KEY_APP_SYSTEM_SHARE, "XRESysSExtPD",
+                                    [Services.appinfo.ID],
+                                    AddonManager.SCOPE_SYSTEM, true);
+        addDirectoryInstallLocation(KEY_APP_SYSTEM_LOCAL, "XRESysLExtPD",
+                                    [Services.appinfo.ID],
+                                    AddonManager.SCOPE_SYSTEM, true);
+        if (hasRegistry) {
+          addRegistryInstallLocation("winreg-app-global",
+                                     Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE,
+                                     AddonManager.SCOPE_SYSTEM);
+        }
+      }
+
+      let defaultPrefs = new Preferences({ defaultBranch: true });
+      this.defaultSkin = defaultPrefs.get(PREF_GENERAL_SKINS_SELECTEDSKIN,
+                                          "classic/1.0");
+      this.currentSkin = Preferences.get(PREF_GENERAL_SKINS_SELECTEDSKIN,
+                                         this.defaultSkin);
+      this.selectedSkin = this.currentSkin;
+      this.applyThemeChange();
+
+      this.minCompatibleAppVersion = Preferences.get(PREF_EM_MIN_COMPAT_APP_VERSION,
+                                                     null);
+      this.minCompatiblePlatformVersion = Preferences.get(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.prefs.addObserver(PREF_E10S_ADDON_BLOCKLIST, this, false);
+      Services.prefs.addObserver(PREF_E10S_ADDON_POLICY, this, false);
+      if (!REQUIRE_SIGNING)
+        Services.prefs.addObserver(PREF_XPI_SIGNATURES_REQUIRED, this, false);
+      Services.obs.addObserver(this, NOTIFICATION_FLUSH_PERMISSIONS, false);
+
+      // Cu.isModuleLoaded can fail here for external XUL apps where there is
+      // no chrome.manifest that defines resource://devtools.
+      if (ResProtocolHandler.hasSubstitution("devtools")) {
+        if (Cu.isModuleLoaded("resource://devtools/client/framework/ToolboxProcess.jsm")) {
+          // If BrowserToolboxProcess is already loaded, set the boolean to true
+          // and do whatever is needed
+          this._toolboxProcessLoaded = true;
+          BrowserToolboxProcess.on("connectionchange",
+                                   this.onDebugConnectionChange.bind(this));
+        } else {
+          // Else, wait for it to load
+          Services.obs.addObserver(this, NOTIFICATION_TOOLBOXPROCESS_LOADED, false);
+        }
+      }
+
+      let flushCaches = this.checkForChanges(aAppChanged, aOldAppVersion,
+                                             aOldPlatformVersion);
+
+      // Changes to installed extensions may have changed which theme is selected
+      this.applyThemeChange();
+
+      AddonManagerPrivate.markProviderSafe(this);
+
+      if (aAppChanged && !this.allAppGlobal &&
+          Preferences.get(PREF_EM_SHOW_MISMATCH_UI, true)) {
+        let addonsToUpdate = this.shouldForceUpdateCheck(aAppChanged);
+        if (addonsToUpdate) {
+          this.showUpgradeUI(addonsToUpdate);
+          flushCaches = true;
+        }
+      }
+
+      if (flushCaches) {
+        Services.obs.notifyObservers(null, "startupcache-invalidate", null);
+        // 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 = Preferences.get(PREF_EM_ENABLED_ADDONS, "");
+
+      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 addon of this.sortBootstrappedAddons()) {
+          try {
+            let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+            file.persistentDescriptor = addon.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(addon.id) !== -1)
+              reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
+            this.callBootstrapMethod(createAddonDetails(addon.id, addon),
+                                     file, "startup", reason);
+          }
+          catch (e) {
+            logger.error("Failed to load bootstrap addon " + addon.id + " from " +
+                         addon.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(aSubject, aTopic, aData) {
+          XPIProvider._closing = true;
+          for (let addon of XPIProvider.sortBootstrappedAddons().reverse()) {
+            // If no scope has been loaded for this add-on then there is no need
+            // to shut it down (should only happen when a bootstrapped add-on is
+            // pending enable)
+            if (!XPIProvider.activeAddons.has(addon.id))
+              continue;
+
+            let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+            file.persistentDescriptor = addon.descriptor;
+            let addonDetails = createAddonDetails(addon.id, addon);
+
+            // If the add-on was pending disable then shut it down and remove it
+            // from the persisted data.
+            if (addon.disable) {
+              XPIProvider.callBootstrapMethod(addonDetails, file, "shutdown",
+                                              BOOTSTRAP_REASONS.ADDON_DISABLE);
+              delete XPIProvider.bootstrappedAddons[addon.id];
+            }
+            else {
+              XPIProvider.callBootstrapMethod(addonDetails, 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(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;
+
+      let timerManager = Cc["@mozilla.org/updates/timer-manager;1"].
+                         getService(Ci.nsIUpdateTimerManager);
+      timerManager.registerTimer("xpi-signature-verification", () => {
+        this.verifySignatures();
+      }, XPI_SIGNATURE_CHECK_PERIOD);
+    }
+    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() {
+    logger.debug("shutdown");
+
+    // Stop anything we were doing asynchronously
+    this.cancelAll();
+
+    this.bootstrappedAddons = {};
+    this.activeAddons.clear();
+    this.enabledAddons = null;
+    this.allAppGlobal = true;
+
+    // If there are pending operations then we must update the list of active
+    // add-ons
+    if (Preferences.get(PREF_PENDING_OPERATIONS, false)) {
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_pending_ops", 1);
+      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;
+    this._addonFileMap.clear();
+
+    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;
+    }
+    logger.debug("Notifying XPI shutdown observers");
+    Services.obs.notifyObservers(null, "xpi-provider-shutdown", null);
+    return undefined;
+  },
+
+  /**
+   * Applies any pending theme change to the preferences.
+   */
+  applyThemeChange: function() {
+    if (!Preferences.get(PREF_DSS_SWITCHPENDING, false))
+      return;
+
+    // Tell the Chrome Registry which Skin to select
+    try {
+      this.selectedSkin = Preferences.get(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);
+  },
+
+  /**
+   * 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.
+   *
+   * @returns False if no update check is needed, otherwise an array of add-on
+   *          IDs to check for updates. Array may be empty if no add-ons can be/need
+   *           to be updated, but the metadata check needs to be performed.
+   */
+  shouldForceUpdateCheck: function(aAppChanged) {
+    AddonManagerPrivate.recordSimpleMeasure("XPIDB_metadata_age", AddonRepository.metadataAge());
+
+    let startupChanges = AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_DISABLED);
+    logger.debug("shouldForceUpdateCheck startupChanges: " + startupChanges.toSource());
+    AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_disabled", startupChanges.length);
+
+    let forceUpdate = [];
+    if (startupChanges.length > 0) {
+    let addons = XPIDatabase.getAddons();
+      for (let addon of addons) {
+        if ((startupChanges.indexOf(addon.id) != -1) &&
+            (addon.permissions() & AddonManager.PERM_CAN_UPGRADE) &&
+            !addon.isCompatible) {
+          logger.debug("shouldForceUpdateCheck: can upgrade disabled add-on " + addon.id);
+          forceUpdate.push(addon.id);
+        }
+      }
+    }
+
+    if (AddonRepository.isMetadataStale()) {
+      logger.debug("shouldForceUpdateCheck: metadata is stale");
+      return forceUpdate;
+    }
+    if (forceUpdate.length > 0) {
+      return forceUpdate;
+    }
+
+    return false;
+  },
+
+  /**
+   * Shows the "Compatibility Updates" UI.
+   *
+   * @param  aAddonIDs
+   *         Array opf addon IDs that were disabled by the application update, and
+   *         should therefore be checked for updates.
+   */
+  showUpgradeUI: function(aAddonIDs) {
+    logger.debug("XPI_showUpgradeUI: " + aAddonIDs.toSource());
+    Services.telemetry.getHistogramById("ADDON_MANAGER_UPGRADE_UI_SHOWN").add(1);
+
+    // Flip a flag to indicate that we interrupted startup with an interactive prompt
+    Services.startup.interrupted = true;
+
+    var variant = Cc["@mozilla.org/variant;1"].
+                  createInstance(Ci.nsIWritableVariant);
+    variant.setFromVariant(aAddonIDs);
+
+    // 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());
+  },
+
+  updateSystemAddons: Task.async(function*() {
+    let systemAddonLocation = XPIProvider.installLocationsByName[KEY_APP_SYSTEM_ADDONS];
+    if (!systemAddonLocation)
+      return;
+
+    // Don't do anything in safe mode
+    if (Services.appinfo.inSafeMode)
+      return;
+
+    // Download the list of system add-ons
+    let url = Preferences.get(PREF_SYSTEM_ADDON_UPDATE_URL, null);
+    if (!url) {
+      yield systemAddonLocation.cleanDirectories();
+      return;
+    }
+
+    url = UpdateUtils.formatUpdateURL(url);
+
+    logger.info(`Starting system add-on update check from ${url}.`);
+    let res = yield ProductAddonChecker.getProductAddonList(url);
+
+    // If there was no list then do nothing.
+    if (!res || !res.gmpAddons) {
+      logger.info("No system add-ons list was returned.");
+      yield systemAddonLocation.cleanDirectories();
+      return;
+    }
+
+    let addonList = new Map(
+      res.gmpAddons.map(spec => [spec.id, { spec, path: null, addon: null }]));
+
+    let getAddonsInLocation = (location) => {
+      return new Promise(resolve => {
+        XPIDatabase.getAddonsInLocation(location, resolve);
+      });
+    };
+
+    let setMatches = (wanted, existing) => {
+      if (wanted.size != existing.size)
+        return false;
+
+      for (let [id, addon] of existing) {
+        let wantedInfo = wanted.get(id);
+
+        if (!wantedInfo)
+          return false;
+        if (wantedInfo.spec.version != addon.version)
+          return false;
+      }
+
+      return true;
+    };
+
+    // If this matches the current set in the profile location then do nothing.
+    let updatedAddons = addonMap(yield getAddonsInLocation(KEY_APP_SYSTEM_ADDONS));
+    if (setMatches(addonList, updatedAddons)) {
+      logger.info("Retaining existing updated system add-ons.");
+      yield systemAddonLocation.cleanDirectories();
+      return;
+    }
+
+    // If this matches the current set in the default location then reset the
+    // updated set.
+    let defaultAddons = addonMap(yield getAddonsInLocation(KEY_APP_SYSTEM_DEFAULTS));
+    if (setMatches(addonList, defaultAddons)) {
+      logger.info("Resetting system add-ons.");
+      systemAddonLocation.resetAddonSet();
+      yield systemAddonLocation.cleanDirectories();
+      return;
+    }
+
+    // Download all the add-ons
+    let downloadAddon = Task.async(function*(item) {
+      try {
+        let sourceAddon = updatedAddons.get(item.spec.id);
+        if (sourceAddon && sourceAddon.version == item.spec.version) {
+          // Copying the file to a temporary location has some benefits. If the
+          // file is locked and cannot be read then we'll fall back to
+          // downloading a fresh copy. It also means we don't have to remember
+          // whether to delete the temporary copy later.
+          try {
+            let path = OS.Path.join(OS.Constants.Path.tmpDir, "tmpaddon");
+            let unique = yield OS.File.openUnique(path);
+            unique.file.close();
+            yield OS.File.copy(sourceAddon._sourceBundle.path, unique.path);
+            // Make sure to update file modification times so this is detected
+            // as a new add-on.
+            yield OS.File.setDates(unique.path);
+            item.path = unique.path;
+          }
+          catch (e) {
+            logger.warn(`Failed make temporary copy of ${sourceAddon._sourceBundle.path}.`, e);
+          }
+        }
+        if (!item.path) {
+          item.path = yield ProductAddonChecker.downloadAddon(item.spec);
+        }
+        item.addon = yield loadManifestFromFile(nsIFile(item.path), systemAddonLocation);
+      }
+      catch (e) {
+        logger.error(`Failed to download system add-on ${item.spec.id}`, e);
+      }
+    });
+    yield Promise.all(Array.from(addonList.values()).map(downloadAddon));
+
+    // The download promises all resolve regardless, now check if they all
+    // succeeded
+    let validateAddon = (item) => {
+      if (item.spec.id != item.addon.id) {
+        logger.warn(`Downloaded system add-on expected to be ${item.spec.id} but was ${item.addon.id}.`);
+        return false;
+      }
+
+      if (item.spec.version != item.addon.version) {
+        logger.warn(`Expected system add-on ${item.spec.id} to be version ${item.spec.version} but was ${item.addon.version}.`);
+        return false;
+      }
+
+      if (!systemAddonLocation.isValidAddon(item.addon))
+        return false;
+
+      return true;
+    }
+
+    if (!Array.from(addonList.values()).every(item => item.path && item.addon && validateAddon(item))) {
+      throw new Error("Rejecting updated system add-on set that either could not " +
+                      "be downloaded or contained unusable add-ons.");
+    }
+
+    // Install into the install location
+    logger.info("Installing new system add-on set");
+    yield systemAddonLocation.installAddonSet(Array.from(addonList.values())
+      .map(a => a.addon));
+  }),
+
+  /**
+   * Verifies that all installed add-ons are still correctly signed.
+   */
+  verifySignatures: function() {
+    XPIDatabase.getAddonList(a => true, (addons) => {
+      Task.spawn(function*() {
+        let changes = {
+          enabled: [],
+          disabled: []
+        };
+
+        for (let addon of addons) {
+          // The add-on might have vanished, we'll catch that on the next startup
+          if (!addon._sourceBundle.exists())
+            continue;
+
+          let signedState = yield verifyBundleSignedState(addon._sourceBundle, addon);
+
+          if (signedState != addon.signedState) {
+            addon.signedState = signedState;
+            AddonManagerPrivate.callAddonListeners("onPropertyChanged",
+                                                   addon.wrapper,
+                                                   ["signedState"]);
+          }
+
+          let disabled = XPIProvider.updateAddonDisabledState(addon);
+          if (disabled !== undefined)
+            changes[disabled ? "disabled" : "enabled"].push(addon.id);
+        }
+
+        XPIDatabase.saveChanges();
+
+        Services.obs.notifyObservers(null, "xpi-signature-changed", JSON.stringify(changes));
+      }).then(null, err => {
+        logger.error("XPI_verifySignature: " + err);
+      })
+    });
+  },
+
+  /**
+   * Persists changes to XPIProvider.bootstrappedAddons to its store (a pref).
+   */
+  persistBootstrappedAddons: function() {
+    // 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() {
+    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) { }
+
+    let TelemetrySession =
+      Cu.import("resource://gre/modules/TelemetrySession.jsm", {}).TelemetrySession;
+    TelemetrySession.setAddOns(data);
+  },
+
+  /**
+   * 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(aManifests) {
+    let changed = false;
+    for (let location of this.installLocations) {
+      aManifests[location.name] = {};
+      // We can't install or uninstall anything in locked locations
+      if (location.locked) {
+        continue;
+      }
+
+      let stagingDir = location.getStagingDir();
+
+      try {
+        if (!stagingDir || !stagingDir.exists() || !stagingDir.isDirectory())
+          continue;
+      }
+      catch (e) {
+        logger.warn("Failed to find staging directory", e);
+        continue;
+      }
+
+      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)
+            throw 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.
+          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 = getManifestFileForDir(stageDirEntry);
+
+          // If the install manifest doesn't exist uninstall this add-on in this
+          // install location.
+          if (!manifest) {
+            logger.debug("Processing uninstall of " + id + " in " + location.name);
+
+            try {
+              let addonFile = location.getLocationForID(id);
+              let addonToUninstall = syncLoadManifestFromFile(addonFile, location);
+              if (addonToUninstall.bootstrap) {
+                this.callBootstrapMethod(addonToUninstall, addonToUninstall._sourceBundle,
+                                         "uninstall", BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+              }
+            }
+            catch (e) {
+              logger.warn("Failed to call uninstall for " + id, e);
+            }
+
+            try {
+              location.uninstallAddon(id);
+              seenFiles.push(stageDirEntry.leafName);
+            }
+            catch (e) {
+              logger.error("Failed to uninstall add-on " + id + " in " + location.name, e);
+            }
+            // The file check later will spot the removal and cleanup the database
+            continue;
+          }
+        }
+
+        aManifests[location.name][id] = null;
+        let existingAddonID = id;
+
+        let jsonfile = stagingDir.clone();
+        jsonfile.append(id + ".json");
+        // Assume this was a foreign install if there is no cached metadata file
+        let foreignInstall = !jsonfile.exists();
+        let addon;
+
+        try {
+          addon = syncLoadManifestFromFile(stageDirEntry, location);
+        }
+        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;
+        }
+
+        if (mustSign(addon.type) &&
+            addon.signedState <= AddonManager.SIGNEDSTATE_MISSING) {
+          logger.warn("Refusing to install staged add-on " + id + " with signed state " + addon.signedState);
+          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 (!foreignInstall) {
+          logger.debug("Found updated metadata for " + id + " in " + location.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);
+            addon.importMetadata(metadata);
+
+            // Pass this through to addMetadata so it knows this add-on was
+            // likely installed through the UI
+            aManifests[location.name][id] = addon;
+          }
+          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 an error and continue
+            logger.error("Unable to read metadata from " + jsonfile.path, e);
+          }
+          finally {
+            fis.close();
+          }
+        }
+        seenFiles.push(jsonfile.leafName);
+
+        existingAddonID = addon.existingAddonID || id;
+
+        var oldBootstrap = null;
+        logger.debug("Processing install of " + id + " in " + location.name);
+        if (existingAddonID in this.bootstrappedAddons) {
+          try {
+            var existingAddon = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+            existingAddon.persistentDescriptor = this.bootstrappedAddons[existingAddonID].descriptor;
+            if (existingAddon.exists()) {
+              oldBootstrap = this.bootstrappedAddons[existingAddonID];
+
+              // We'll be replacing a currently active bootstrapped add-on so
+              // call its uninstall method
+              let newVersion = addon.version;
+              let oldVersion = oldBootstrap.version;
+              let uninstallReason = Services.vc.compare(oldVersion, newVersion) < 0 ?
+                                    BOOTSTRAP_REASONS.ADDON_UPGRADE :
+                                    BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
+
+              this.callBootstrapMethod(createAddonDetails(existingAddonID, oldBootstrap),
+                                       existingAddon, "uninstall", uninstallReason,
+                                       { newVersion: newVersion });
+              this.unloadBootstrapScope(existingAddonID);
+              flushChromeCaches();
+            }
+          }
+          catch (e) {
+          }
+        }
+
+        try {
+          addon._sourceBundle = location.installAddon({
+            id,
+            source: stageDirEntry,
+            existingAddonID
+          });
+        }
+        catch (e) {
+          logger.error("Failed to install staged add-on " + id + " in " + location.name,
+                e);
+          // Re-create the staged install
+          new StagedAddonInstall(location, stageDirEntry, addon);
+          // Make sure not to delete the cached manifest json file
+          seenFiles.pop();
+
+          delete aManifests[location.name][id];
+
+          if (oldBootstrap) {
+            // Re-install the old add-on
+            this.callBootstrapMethod(createAddonDetails(existingAddonID, oldBootstrap),
+                                     existingAddon, "install",
+                                     BOOTSTRAP_REASONS.ADDON_INSTALL);
+          }
+          continue;
+        }
+      }
+
+      try {
+        location.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);
+      }
+    }
+    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
+   * @param  aAppChanged
+   *         See checkForChanges
+   * @return true if any new add-ons were installed
+   */
+  installDistributionAddons: function(aManifests, aAppChanged) {
+    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;
+      }
+
+      /* If this is not an upgrade and we've already handled this extension
+       * just continue */
+      if (!aAppChanged && Preferences.isSet(PREF_BRANCH_INSTALLED_ADDON + id)) {
+        continue;
+      }
+
+      let addon;
+      try {
+        addon = syncLoadManifestFromFile(entry, profileLocation);
+      }
+      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 = syncLoadManifestFromFile(existingEntry, profileLocation);
+
+          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 (Preferences.get(PREF_BRANCH_INSTALLED_ADDON + id, false)) {
+        continue;
+      }
+
+      // Install the add-on
+      try {
+        addon._sourceBundle = profileLocation.installAddon({ id, source: entry, action: "copy" });
+        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;
+  },
+
+  /**
+   * Imports the xpinstall permissions from preferences into the permissions
+   * manager for the user to change later.
+   */
+  importPermissions: function() {
+    PermissionsUtils.importFromPrefs(PREF_XPI_PERMISSIONS_BRANCH,
+                                     XPI_PERMISSION);
+  },
+
+  getDependentAddons: function(aAddon) {
+    return Array.from(XPIDatabase.getAddons())
+                .filter(addon => addon.dependencies.includes(aAddon.id));
+  },
+
+  /**
+   * Checks for any changes that have occurred since the last time the
+   * application was launched.
+   *
+   * @param  aAppChanged
+   *         A tri-state value. Undefined means the current profile was created
+   *         for this session, true means the profile already existed but was
+   *         last used with an application with a different version number,
+   *         false means that the profile was last used by this version of the
+   *         application.
+   * @param  aOldAppVersion
+   *         The version of the application last run with this profile or null
+   *         if it is a new profile or the version is unknown
+   * @param  aOldPlatformVersion
+   *         The version of the platform last run with this profile or null
+   *         if it is a new profile or the version is unknown
+   * @return true if a change requiring a restart was detected
+   */
+  checkForChanges: function(aAppChanged, aOldAppVersion,
+                                                aOldPlatformVersion) {
+    logger.debug("checkForChanges");
+
+    // Keep track of whether and why we need to open and update the database at
+    // startup time.
+    let updateReasons = [];
+    if (aAppChanged) {
+      updateReasons.push("appChanged");
+    }
+
+    // Load the list of bootstrapped add-ons first so processFileChanges can
+    // modify it
+    // XXX eventually get rid of bootstrappedAddons
+    try {
+      this.bootstrappedAddons = JSON.parse(Preferences.get(PREF_BOOTSTRAP_ADDONS,
+                                           "{}"));
+    } catch (e) {
+      logger.warn("Error parsing enabled bootstrapped extensions cache", e);
+    }
+
+    // First install any new add-ons into the locations, if there are any
+    // changes then we must update the database with the information in the
+    // install locations
+    let manifests = {};
+    let updated = this.processPendingFileChanges(manifests);
+    if (updated) {
+      updateReasons.push("pendingFileChanges");
+    }
+
+    // This will be true if the previous session made changes that affect the
+    // active state of add-ons but didn't commit them properly (normally due
+    // to the application crashing)
+    let hasPendingChanges = Preferences.get(PREF_PENDING_OPERATIONS);
+    if (hasPendingChanges) {
+      updateReasons.push("hasPendingChanges");
+    }
+
+    // If the application has changed then check for new distribution add-ons
+    if (Preferences.get(PREF_INSTALL_DISTRO_ADDONS, true))
+    {
+      updated = this.installDistributionAddons(manifests, aAppChanged);
+      if (updated) {
+        updateReasons.push("installDistributionAddons");
+      }
+    }
+
+    // Telemetry probe added around getInstallState() to check perf
+    let telemetryCaptureTime = Cu.now();
+    let installChanged = XPIStates.getInstallState();
+    let telemetry = Services.telemetry;
+    telemetry.getHistogramById("CHECK_ADDONS_MODIFIED_MS").add(Math.round(Cu.now() - telemetryCaptureTime));
+    if (installChanged) {
+      updateReasons.push("directoryState");
+    }
+
+    let haveAnyAddons = (XPIStates.size > 0);
+
+    // If the schema appears to have changed then we should update the database
+    if (DB_SCHEMA != Preferences.get(PREF_DB_SCHEMA, 0)) {
+      // If we don't have any add-ons, just update the pref, since we don't need to
+      // write the database
+      if (!haveAnyAddons) {
+        logger.debug("Empty XPI database, setting schema version preference to " + DB_SCHEMA);
+        Services.prefs.setIntPref(PREF_DB_SCHEMA, DB_SCHEMA);
+      }
+      else {
+        updateReasons.push("schemaChanged");
+      }
+    }
+
+    // If the database doesn't exist and there are add-ons installed then we
+    // must update the database however if there are no add-ons then there is
+    // no need to update the database.
+    let dbFile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true);
+    if (!dbFile.exists() && haveAnyAddons) {
+      updateReasons.push("needNewDatabase");
+    }
+
+    // XXX This will go away when we fold bootstrappedAddons into XPIStates.
+    if (updateReasons.length == 0) {
+      let bootstrapDescriptors = new Set(Object.keys(this.bootstrappedAddons)
+        .map(b => this.bootstrappedAddons[b].descriptor));
+
+      for (let location of XPIStates.db.values()) {
+        for (let state of location.values()) {
+          bootstrapDescriptors.delete(state.descriptor);
+        }
+      }
+
+      if (bootstrapDescriptors.size > 0) {
+        logger.warn("Bootstrap state is invalid (missing add-ons: "
+            + Array.from(bootstrapDescriptors).join(", ") + ")");
+        updateReasons.push("missingBootstrapAddon");
+      }
+    }
+
+    // Catch and log any errors during the main startup
+    try {
+      let extensionListChanged = false;
+      // If the database needs to be updated then open it and then update it
+      // from the filesystem
+      if (updateReasons.length > 0) {
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_load_reasons", updateReasons);
+        XPIDatabase.syncLoadDB(false);
+        try {
+          extensionListChanged = XPIDatabaseReconcile.processFileChanges(manifests,
+                                                                         aAppChanged,
+                                                                         aOldAppVersion,
+                                                                         aOldPlatformVersion,
+                                                                         updateReasons.includes("schemaChanged"));
+        }
+        catch (e) {
+          logger.error("Failed to process extension changes at startup", e);
+        }
+      }
+
+      if (aAppChanged) {
+        // When upgrading the app and using a custom skin make sure it is still
+        // compatible otherwise switch back the default
+        if (this.currentSkin != this.defaultSkin) {
+          let oldSkin = XPIDatabase.getVisibleAddonForInternalName(this.currentSkin);
+          if (!oldSkin || oldSkin.disabled)
+            this.enableDefaultTheme();
+        }
+
+        // When upgrading remove the old extensions cache to force older
+        // versions to rescan the entire list of extensions
+        let oldCache = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_CACHE], true);
+        try {
+          if (oldCache.exists())
+            oldCache.remove(true);
+        }
+        catch (e) {
+          logger.warn("Unable to remove old extension cache " + oldCache.path, e);
+        }
+      }
+
+      // If the application crashed before completing any pending operations then
+      // we should perform them now.
+      if (extensionListChanged || hasPendingChanges) {
+        logger.debug("Updating database with changes to installed add-ons");
+        XPIDatabase.updateActiveAddons();
+        Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
+                                   !XPIDatabase.writeAddonsList());
+        Services.prefs.setCharPref(PREF_BOOTSTRAP_ADDONS,
+                                   JSON.stringify(this.bootstrappedAddons));
+        return true;
+      }
+
+      logger.debug("No changes found");
+    }
+    catch (e) {
+      logger.error("Error during startup file checks", e);
+    }
+
+    // Check that the add-ons list still exists
+    let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST],
+                                       true);
+    // the addons list file should exist if and only if we have add-ons installed
+    if (addonsList.exists() != haveAnyAddons) {
+      logger.debug("Add-ons list is invalid, rebuilding");
+      XPIDatabase.writeAddonsList();
+    }
+
+    return false;
+  },
+
+  /**
+   * Called to test whether this provider supports installing a particular
+   * mimetype.
+   *
+   * @param  aMimetype
+   *         The mimetype to check for
+   * @return true if the mimetype is application/x-xpinstall
+   */
+  supportsMimetype: function(aMimetype) {
+    return aMimetype == "application/x-xpinstall";
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons is enabled.
+   *
+   * @return true if installing is enabled
+   */
+  isInstallEnabled: function() {
+    // Default to enabled if the preference does not exist
+    return Preferences.get(PREF_XPI_ENABLED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons by direct URL requests is
+   * whitelisted.
+   *
+   * @return true if installing by direct requests is whitelisted
+   */
+  isDirectRequestWhitelisted: function() {
+    // Default to whitelisted if the preference does not exist.
+    return Preferences.get(PREF_XPI_DIRECT_WHITELISTED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons from file referrers is
+   * whitelisted.
+   *
+   * @return true if installing from file referrers is whitelisted
+   */
+  isFileRequestWhitelisted: function() {
+    // Default to whitelisted if the preference does not exist.
+    return Preferences.get(PREF_XPI_FILE_WHITELISTED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons from a URI is allowed.
+   *
+   * @param  aInstallingPrincipal
+   *         The nsIPrincipal that initiated the install
+   * @return true if installing is allowed
+   */
+  isInstallAllowed: function(aInstallingPrincipal) {
+    if (!this.isInstallEnabled())
+      return false;
+
+    let uri = aInstallingPrincipal.URI;
+
+    // Direct requests without a referrer are either whitelisted or blocked.
+    if (!uri)
+      return this.isDirectRequestWhitelisted();
+
+    // Local referrers can be whitelisted.
+    if (this.isFileRequestWhitelisted() &&
+        (uri.schemeIs("chrome") || uri.schemeIs("file")))
+      return true;
+
+    this.importPermissions();
+
+    let permission = Services.perms.testPermissionFromPrincipal(aInstallingPrincipal, XPI_PERMISSION);
+    if (permission == Ci.nsIPermissionManager.DENY_ACTION)
+      return false;
+
+    let requireWhitelist = Preferences.get(PREF_XPI_WHITELIST_REQUIRED, true);
+    if (requireWhitelist && (permission != Ci.nsIPermissionManager.ALLOW_ACTION))
+      return false;
+
+    let requireSecureOrigin = Preferences.get(PREF_INSTALL_REQUIRESECUREORIGIN, true);
+    let safeSchemes = ["https", "chrome", "file"];
+    if (requireSecureOrigin && safeSchemes.indexOf(uri.scheme) == -1)
+      return false;
+
+    return true;
+  },
+
+  /**
+   * Called to get an AddonInstall to download and install an add-on from a URL.
+   *
+   * @param  aUrl
+   *         The URL to be installed
+   * @param  aHash
+   *         A hash for the install
+   * @param  aName
+   *         A name for the install
+   * @param  aIcons
+   *         Icon URLs for the install
+   * @param  aVersion
+   *         A version for the install
+   * @param  aBrowser
+   *         The browser performing the install
+   * @param  aCallback
+   *         A callback to pass the AddonInstall to
+   */
+  getInstallForURL: function(aUrl, aHash, aName, aIcons, aVersion, aBrowser,
+                             aCallback) {
+    createDownloadInstall(function(aInstall) {
+      aCallback(aInstall.wrapper);
+    }, aUrl, aHash, aName, aIcons, aVersion, aBrowser);
+  },
+
+  /**
+   * Called to get an AddonInstall to install an add-on from a local file.
+   *
+   * @param  aFile
+   *         The file to be installed
+   * @param  aCallback
+   *         A callback to pass the AddonInstall to
+   */
+  getInstallForFile: function(aFile, aCallback) {
+    createLocalInstall(aFile).then(install => {
+      aCallback(install ? install.wrapper : null);
+    });
+  },
+
+  /**
+   * Temporarily installs add-on from a local XPI file or directory.
+   * As this is intended for development, the signature is not checked and
+   * the add-on does not persist on application restart.
+   *
+   * @param aFile
+   *        An nsIFile for the unpacked add-on directory or XPI file.
+   *
+   * @return See installAddonFromLocation return value.
+   */
+  installTemporaryAddon: function(aFile) {
+    return this.installAddonFromLocation(aFile, TemporaryInstallLocation);
+  },
+
+  /**
+   * Permanently installs add-on from a local XPI file or directory.
+   * The signature is checked but the add-on persist on application restart.
+   *
+   * @param aFile
+   *        An nsIFile for the unpacked add-on directory or XPI file.
+   *
+   * @return See installAddonFromLocation return value.
+   */
+  installAddonFromSources: Task.async(function*(aFile) {
+    let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
+    return this.installAddonFromLocation(aFile, location, "proxy");
+  }),
+
+  /**
+   * Installs add-on from a local XPI file or directory.
+   *
+   * @param aFile
+   *        An nsIFile for the unpacked add-on directory or XPI file.
+   * @param aInstallLocation
+   *        Define a custom install location object to use for the install.
+   * @param aInstallAction
+   *        Optional action mode to use when installing the addon
+   *        (see MutableDirectoryInstallLocation.installAddon)
+   *
+   * @return a Promise that resolves to an Addon object on success, or rejects
+   *         if the add-on is not a valid restartless add-on or if the
+   *         same ID is already installed.
+   */
+  installAddonFromLocation: Task.async(function*(aFile, aInstallLocation, aInstallAction) {
+    if (aFile.exists() && aFile.isFile()) {
+      flushJarCache(aFile);
+    }
+    let addon = yield loadManifestFromFile(aFile, aInstallLocation);
+
+    aInstallLocation.installAddon({ id: addon.id, source: aFile, action: aInstallAction });
+
+    if (addon.appDisabled) {
+      let message = `Add-on ${addon.id} is not compatible with application version.`;
+
+      let app = addon.matchingTargetApplication;
+      if (app) {
+        if (app.minVersion) {
+          message += ` add-on minVersion: ${app.minVersion}.`;
+        }
+        if (app.maxVersion) {
+          message += ` add-on maxVersion: ${app.maxVersion}.`;
+        }
+      }
+      throw new Error(message);
+    }
+
+    if (!addon.bootstrap) {
+      throw new Error("Only restartless (bootstrap) add-ons"
+                    + " can be installed from sources:", addon.id);
+    }
+    let installReason = BOOTSTRAP_REASONS.ADDON_INSTALL;
+    let oldAddon = yield new Promise(
+                   resolve => XPIDatabase.getVisibleAddonForID(addon.id, resolve));
+    if (oldAddon) {
+      if (!oldAddon.bootstrap) {
+        logger.warn("Non-restartless Add-on is already installed", addon.id);
+        throw new Error("Non-restartless add-on with ID "
+                        + oldAddon.id + " is already installed");
+      }
+      else {
+        logger.warn("Addon with ID " + oldAddon.id + " already installed,"
+                    + " older version will be disabled");
+
+        let existingAddonID = oldAddon.id;
+        let existingAddon = oldAddon._sourceBundle;
+
+        // We'll be replacing a currently active bootstrapped add-on so
+        // call its uninstall method
+        let newVersion = addon.version;
+        let oldVersion = oldAddon.version;
+        if (Services.vc.compare(newVersion, oldVersion) >= 0) {
+          installReason = BOOTSTRAP_REASONS.ADDON_UPGRADE;
+        } else {
+          installReason = BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
+        }
+        let uninstallReason = installReason;
+
+        if (oldAddon.active) {
+          XPIProvider.callBootstrapMethod(oldAddon, existingAddon,
+                                          "shutdown", uninstallReason,
+                                          { newVersion });
+        }
+        this.callBootstrapMethod(oldAddon, existingAddon,
+                                 "uninstall", uninstallReason, { newVersion });
+        this.unloadBootstrapScope(existingAddonID);
+        flushChromeCaches();
+      }
+    }
+
+    let file = addon._sourceBundle;
+
+    XPIProvider._addURIMapping(addon.id, file);
+    XPIProvider.callBootstrapMethod(addon, file, "install", installReason);
+    addon.state = AddonManager.STATE_INSTALLED;
+    logger.debug("Install of temporary addon in " + aFile.path + " completed.");
+    addon.visible = true;
+    addon.enabled = true;
+    addon.active = true;
+
+    addon = XPIDatabase.addAddonMetadata(addon, file.persistentDescriptor);
+
+    XPIStates.addAddon(addon);
+    XPIDatabase.saveChanges();
+    XPIStates.save();
+
+    AddonManagerPrivate.callAddonListeners("onInstalling", addon.wrapper,
+                                           false);
+    XPIProvider.callBootstrapMethod(addon, file, "startup",
+                                    BOOTSTRAP_REASONS.ADDON_ENABLE);
+    AddonManagerPrivate.callInstallListeners("onExternalInstall",
+                                             null, addon.wrapper,
+                                             oldAddon ? oldAddon.wrapper : null,
+                                             false);
+    AddonManagerPrivate.callAddonListeners("onInstalled", addon.wrapper);
+
+    return addon.wrapper;
+  }),
+
+  /**
+   * Returns an Addon corresponding to an instance ID.
+   * @param aInstanceID
+   *        An Addon Instance ID
+   * @return {Promise}
+   * @resolves The found Addon or null if no such add-on exists.
+   * @rejects  Never
+   * @throws if the aInstanceID argument is not specified
+   */
+   getAddonByInstanceID: function(aInstanceID) {
+     if (!aInstanceID || typeof aInstanceID != "symbol")
+       throw Components.Exception("aInstanceID must be a Symbol()",
+                                  Cr.NS_ERROR_INVALID_ARG);
+
+     for (let [id, val] of this.activeAddons) {
+       if (aInstanceID == val.instanceID) {
+         if (val.safeWrapper) {
+           return Promise.resolve(val.safeWrapper);
+         }
+
+         return new Promise(resolve => {
+           this.getAddonByID(id, function(addon) {
+             val.safeWrapper = new PrivateWrapper(addon);
+             resolve(val.safeWrapper);
+           });
+         });
+       }
+     }
+
+     return Promise.resolve(null);
+   },
+
+  /**
+   * Removes an AddonInstall from the list of active installs.
+   *
+   * @param  install
+   *         The AddonInstall to remove
+   */
+  removeActiveInstall: function(aInstall) {
+    this.installs.delete(aInstall);
+  },
+
+  /**
+   * Called to get an Addon with a particular ID.
+   *
+   * @param  aId
+   *         The ID of the add-on to retrieve
+   * @param  aCallback
+   *         A callback to pass the Addon to
+   */
+  getAddonByID: function(aId, aCallback) {
+    XPIDatabase.getVisibleAddonForID (aId, function(aAddon) {
+      aCallback(aAddon ? aAddon.wrapper : null);
+    });
+  },
+
+  /**
+   * Called to get Addons of a particular type.
+   *
+   * @param  aTypes
+   *         An array of types to fetch. Can be null to get all types.
+   * @param  aCallback
+   *         A callback to pass an array of Addons to
+   */
+  getAddonsByTypes: function(aTypes, aCallback) {
+    let typesToGet = getAllAliasesForTypes(aTypes);
+
+    XPIDatabase.getVisibleAddons(typesToGet, function(aAddons) {
+      aCallback(aAddons.map(a => a.wrapper));
+    });
+  },
+
+  /**
+   * Obtain an Addon having the specified Sync GUID.
+   *
+   * @param  aGUID
+   *         String GUID of add-on to retrieve
+   * @param  aCallback
+   *         A callback to pass the Addon to. Receives null if not found.
+   */
+  getAddonBySyncGUID: function(aGUID, aCallback) {
+    XPIDatabase.getAddonBySyncGUID(aGUID, function(aAddon) {
+      aCallback(aAddon ? aAddon.wrapper : null);
+    });
+  },
+
+  /**
+   * Called to get Addons that have pending operations.
+   *
+   * @param  aTypes
+   *         An array of types to fetch. Can be null to get all types
+   * @param  aCallback
+   *         A callback to pass an array of Addons to
+   */
+  getAddonsWithOperationsByTypes: function(aTypes, aCallback) {
+    let typesToGet = getAllAliasesForTypes(aTypes);
+
+    XPIDatabase.getVisibleAddonsWithPendingOperations(typesToGet, function(aAddons) {
+      let results = aAddons.map(a => a.wrapper);
+      for (let install of XPIProvider.installs) {
+        if (install.state == AddonManager.STATE_INSTALLED &&
+            !(install.addon.inDatabase))
+          results.push(install.addon.wrapper);
+      }
+      aCallback(results);
+    });
+  },
+
+  /**
+   * Called to get the current AddonInstalls, optionally limiting to a list of
+   * types.
+   *
+   * @param  aTypes
+   *         An array of types or null to get all types
+   * @param  aCallback
+   *         A callback to pass the array of AddonInstalls to
+   */
+  getInstallsByTypes: function(aTypes, aCallback) {
+    let results = [...this.installs];
+    if (aTypes) {
+      results = results.filter(install => {
+        return aTypes.includes(getExternalType(install.type));
+      });
+    }
+
+    aCallback(results.map(install => install.wrapper));
+  },
+
+  /**
+   * Synchronously map a URI to the corresponding Addon ID.
+   *
+   * Mappable URIs are limited to in-application resources belonging to the
+   * add-on, such as Javascript compartments, XUL windows, XBL bindings, etc.
+   * but do not include URIs from meta data, such as the add-on homepage.
+   *
+   * @param  aURI
+   *         nsIURI to map or null
+   * @return string containing the Addon ID
+   * @see    AddonManager.mapURIToAddonID
+   * @see    amIAddonManager.mapURIToAddonID
+   */
+  mapURIToAddonID: function(aURI) {
+    // Returns `null` instead of empty string if the URI can't be mapped.
+    return AddonPathService.mapURIToAddonId(aURI) || null;
+  },
+
+  /**
+   * Called when a new add-on has been enabled when only one add-on of that type
+   * can be enabled.
+   *
+   * @param  aId
+   *         The ID of the newly enabled add-on
+   * @param  aType
+   *         The type of the newly enabled add-on
+   * @param  aPendingRestart
+   *         true if the newly enabled add-on will only become enabled after a
+   *         restart
+   */
+  addonChanged: function(aId, aType, aPendingRestart) {
+    // We only care about themes in this provider
+    if (aType != "theme")
+      return;
+
+    if (!aId) {
+      // Fallback to the default theme when no theme was enabled
+      this.enableDefaultTheme();
+      return;
+    }
+
+    // Look for the previously enabled theme and find the internalName of the
+    // currently selected theme
+    let previousTheme = null;
+    let newSkin = this.defaultSkin;
+    let addons = XPIDatabase.getAddonsByType("theme");
+    for (let theme of addons) {
+      if (!theme.visible)
+        return;
+      if (theme.id == aId)
+        newSkin = theme.internalName;
+      else if (theme.userDisabled == false && !theme.pendingUninstall)
+        previousTheme = theme;
+    }
+
+    if (aPendingRestart) {
+      Services.prefs.setBoolPref(PREF_DSS_SWITCHPENDING, true);
+      Services.prefs.setCharPref(PREF_DSS_SKIN_TO_SELECT, newSkin);
+    }
+    else if (newSkin == this.currentSkin) {
+      try {
+        Services.prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
+      }
+      catch (e) { }
+      try {
+        Services.prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
+      }
+      catch (e) { }
+    }
+    else {
+      Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN, newSkin);
+      this.currentSkin = newSkin;
+    }
+    this.selectedSkin = newSkin;
+
+    // Flush the preferences to disk so they don't get out of sync with the
+    // database
+    Services.prefs.savePrefFile(null);
+
+    // Mark the previous theme as disabled. This won't cause recursion since
+    // only enabled calls notifyAddonChanged.
+    if (previousTheme)
+      this.updateAddonDisabledState(previousTheme, true);
+  },
+
+  /**
+   * Update the appDisabled property for all add-ons.
+   */
+  updateAddonAppDisabledStates: function() {
+    let addons = XPIDatabase.getAddons();
+    for (let addon of addons) {
+      this.updateAddonDisabledState(addon);
+    }
+  },
+
+  /**
+   * Update the repositoryAddon property for all add-ons.
+   *
+   * @param  aCallback
+   *         Function to call when operation is complete.
+   */
+  updateAddonRepositoryData: function(aCallback) {
+    XPIDatabase.getVisibleAddons(null, aAddons => {
+      let pending = aAddons.length;
+      logger.debug("updateAddonRepositoryData found " + pending + " visible add-ons");
+      if (pending == 0) {
+        aCallback();
+        return;
+      }
+
+      function notifyComplete() {
+        if (--pending == 0)
+          aCallback();
+      }
+
+      for (let addon of aAddons) {
+        AddonRepository.getCachedAddonByID(addon.id, aRepoAddon => {
+          if (aRepoAddon) {
+            logger.debug("updateAddonRepositoryData got info for " + addon.id);
+            addon._repositoryAddon = aRepoAddon;
+            addon.compatibilityOverrides = aRepoAddon.compatibilityOverrides;
+            this.updateAddonDisabledState(addon);
+          }
+
+          notifyComplete();
+        });
+      }
+    });
+  },
+
+  /**
+   * When the previously selected theme is removed this method will be called
+   * to enable the default theme.
+   */
+  enableDefaultTheme: function() {
+    logger.debug("Activating default theme");
+    let addon = XPIDatabase.getVisibleAddonForInternalName(this.defaultSkin);
+    if (addon) {
+      if (addon.userDisabled) {
+        this.updateAddonDisabledState(addon, false);
+      }
+      else if (!this.extensionsActive) {
+        // During startup we may end up trying to enable the default theme when
+        // the database thinks it is already enabled (see f.e. bug 638847). In
+        // this case just force the theme preferences to be correct
+        Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
+                                   addon.internalName);
+        this.currentSkin = this.selectedSkin = addon.internalName;
+        Preferences.reset(PREF_DSS_SKIN_TO_SELECT);
+        Preferences.reset(PREF_DSS_SWITCHPENDING);
+      }
+      else {
+        logger.warn("Attempting to activate an already active default theme");
+      }
+    }
+    else {
+      logger.warn("Unable to activate the default theme");
+    }
+  },
+
+  onDebugConnectionChange: function(aEvent, aWhat, aConnection) {
+    if (aWhat != "opened")
+      return;
+
+    for (let [id, val] of this.activeAddons) {
+      aConnection.setAddonOptions(
+        id, { global: val.debugGlobal || val.bootstrapScope });
+    }
+  },
+
+  /**
+   * Notified when a preference we're interested in has changed.
+   *
+   * @see nsIObserver
+   */
+  observe: function(aSubject, aTopic, aData) {
+    if (aTopic == NOTIFICATION_FLUSH_PERMISSIONS) {
+      if (!aData || aData == XPI_PERMISSION) {
+        this.importPermissions();
+      }
+      return;
+    }
+    else if (aTopic == NOTIFICATION_TOOLBOXPROCESS_LOADED) {
+      Services.obs.removeObserver(this, NOTIFICATION_TOOLBOXPROCESS_LOADED, false);
+      this._toolboxProcessLoaded = true;
+      BrowserToolboxProcess.on("connectionchange",
+                               this.onDebugConnectionChange.bind(this));
+    }
+
+    if (aTopic == "nsPref:changed") {
+      switch (aData) {
+      case PREF_EM_MIN_COMPAT_APP_VERSION:
+        this.minCompatibleAppVersion = Preferences.get(PREF_EM_MIN_COMPAT_APP_VERSION,
+                                                       null);
+        this.updateAddonAppDisabledStates();
+        break;
+      case PREF_EM_MIN_COMPAT_PLATFORM_VERSION:
+        this.minCompatiblePlatformVersion = Preferences.get(PREF_EM_MIN_COMPAT_PLATFORM_VERSION,
+                                                            null);
+        this.updateAddonAppDisabledStates();
+        break;
+      case PREF_XPI_SIGNATURES_REQUIRED:
+        this.updateAddonAppDisabledStates();
+        break;
+
+      case PREF_E10S_ADDON_BLOCKLIST:
+      case PREF_E10S_ADDON_POLICY:
+        XPIDatabase.updateAddonsBlockingE10s();
+        break;
+      }
+    }
+  },
+
+  /**
+   * Determine if an add-on should be blocking e10s if enabled.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if enabling the add-on should block e10s
+   */
+  isBlockingE10s: function(aAddon) {
+    if (aAddon.type != "extension" &&
+        aAddon.type != "webextension" &&
+        aAddon.type != "theme")
+      return false;
+
+    // The hotfix is exempt
+    let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined);
+    if (hotfixID && hotfixID == aAddon.id)
+      return false;
+
+    // The default theme is exempt
+    if (aAddon.type == "theme" &&
+        aAddon.internalName == XPIProvider.defaultSkin)
+      return false;
+
+    // System add-ons are exempt
+    let locName = aAddon._installLocation ? aAddon._installLocation.name
+                                          : undefined;
+    if (locName == KEY_APP_SYSTEM_DEFAULTS ||
+        locName == KEY_APP_SYSTEM_ADDONS)
+      return false;
+
+    if (isAddonPartOfE10SRollout(aAddon)) {
+      Preferences.set(PREF_E10S_HAS_NONEXEMPT_ADDON, true);
+      return false;
+    }
+
+    logger.debug("Add-on " + aAddon.id + " blocks e10s rollout.");
+    return true;
+  },
+
+  /**
+   * In some cases having add-ons active blocks e10s but turning off e10s
+   * requires a restart so some add-ons that are normally restartless will
+   * require a restart to install or enable.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if enabling the add-on requires a restart
+   */
+  e10sBlocksEnabling: function(aAddon) {
+    // If the preference isn't set then don't block anything
+    if (!Preferences.get(PREF_E10S_BLOCK_ENABLE, false))
+      return false;
+
+    // If e10s isn't active then don't block anything
+    if (!Services.appinfo.browserTabsRemoteAutostart)
+      return false;
+
+    return this.isBlockingE10s(aAddon);
+  },
+
+  /**
+   * Tests whether enabling an add-on will require a restart.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if the operation requires a restart
+   */
+  enableRequiresRestart: function(aAddon) {
+    // If the platform couldn't have activated extensions then we can make
+    // changes without any restart.
+    if (!this.extensionsActive)
+      return false;
+
+    // If the application is in safe mode then any change can be made without
+    // restarting
+    if (Services.appinfo.inSafeMode)
+      return false;
+
+    // Anything that is active is already enabled
+    if (aAddon.active)
+      return false;
+
+    if (aAddon.type == "theme") {
+      // If dynamic theme switching is enabled then switching themes does not
+      // require a restart
+      if (Preferences.get(PREF_EM_DSS_ENABLED))
+        return false;
+
+      // If the theme is already the theme in use then no restart is necessary.
+      // This covers the case where the default theme is in use but a
+      // lightweight theme is considered active.
+      return aAddon.internalName != this.currentSkin;
+    }
+
+    if (this.e10sBlocksEnabling(aAddon))
+      return true;
+
+    return !aAddon.bootstrap;
+  },
+
+  /**
+   * Tests whether disabling an add-on will require a restart.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if the operation requires a restart
+   */
+  disableRequiresRestart: function(aAddon) {
+    // If the platform couldn't have activated up extensions then we can make
+    // changes without any restart.
+    if (!this.extensionsActive)
+      return false;
+
+    // If the application is in safe mode then any change can be made without
+    // restarting
+    if (Services.appinfo.inSafeMode)
+      return false;
+
+    // Anything that isn't active is already disabled
+    if (!aAddon.active)
+      return false;
+
+    if (aAddon.type == "theme") {
+      // If dynamic theme switching is enabled then switching themes does not
+      // require a restart
+      if (Preferences.get(PREF_EM_DSS_ENABLED))
+        return false;
+
+      // Non-default themes always require a restart to disable since it will
+      // be switching from one theme to another or to the default theme and a
+      // lightweight theme.
+      if (aAddon.internalName != this.defaultSkin)
+        return true;
+
+      // The default theme requires a restart to disable if we are in the
+      // process of switching to a different theme. Note that this makes the
+      // disabled flag of operationsRequiringRestart incorrect for the default
+      // theme (it will be false most of the time). Bug 520124 would be required
+      // to fix it. For the UI this isn't a problem since we never try to
+      // disable or uninstall the default theme.
+      return this.selectedSkin != this.currentSkin;
+    }
+
+    return !aAddon.bootstrap;
+  },
+
+  /**
+   * Tests whether installing an add-on will require a restart.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if the operation requires a restart
+   */
+  installRequiresRestart: function(aAddon) {
+    // If the platform couldn't have activated up extensions then we can make
+    // changes without any restart.
+    if (!this.extensionsActive)
+      return false;
+
+    // If the application is in safe mode then any change can be made without
+    // restarting
+    if (Services.appinfo.inSafeMode)
+      return false;
+
+    // Add-ons that are already installed don't require a restart to install.
+    // This wouldn't normally be called for an already installed add-on (except
+    // for forming the operationsRequiringRestart flags) so is really here as
+    // a safety measure.
+    if (aAddon.inDatabase)
+      return false;
+
+    // If we have an AddonInstall for this add-on then we can see if there is
+    // an existing installed add-on with the same ID
+    if ("_install" in aAddon && aAddon._install) {
+      // If there is an existing installed add-on and uninstalling it would
+      // require a restart then installing the update will also require a
+      // restart
+      let existingAddon = aAddon._install.existingAddon;
+      if (existingAddon && this.uninstallRequiresRestart(existingAddon))
+        return true;
+    }
+
+    // If the add-on is not going to be active after installation then it
+    // doesn't require a restart to install.
+    if (aAddon.disabled)
+      return false;
+
+    if (this.e10sBlocksEnabling(aAddon))
+      return true;
+
+    // Themes will require a restart (even if dynamic switching is enabled due
+    // to some caching issues) and non-bootstrapped add-ons will require a
+    // restart
+    return aAddon.type == "theme" || !aAddon.bootstrap;
+  },
+
+  /**
+   * Tests whether uninstalling an add-on will require a restart.
+   *
+   * @param  aAddon
+   *         The add-on to test
+   * @return true if the operation requires a restart
+   */
+  uninstallRequiresRestart: function(aAddon) {
+    // If the platform couldn't have activated up extensions then we can make
+    // changes without any restart.
+    if (!this.extensionsActive)
+      return false;
+
+    // If the application is in safe mode then any change can be made without
+    // restarting
+    if (Services.appinfo.inSafeMode)
+      return false;
+
+    // If the add-on can be disabled without a restart then it can also be
+    // uninstalled without a restart
+    return this.disableRequiresRestart(aAddon);
+  },
+
+  /**
+   * Loads a bootstrapped add-on's bootstrap.js into a sandbox and the reason
+   * values as constants in the scope. This will also add information about the
+   * add-on to the bootstrappedAddons dictionary and notify the crash reporter
+   * that new add-ons have been loaded.
+   *
+   * @param  aId
+   *         The add-on's ID
+   * @param  aFile
+   *         The nsIFile for the add-on
+   * @param  aVersion
+   *         The add-on's version
+   * @param  aType
+   *         The type for the add-on
+   * @param  aMultiprocessCompatible
+   *         Boolean indicating whether the add-on is compatible with electrolysis.
+   * @param  aRunInSafeMode
+   *         Boolean indicating whether the add-on can run in safe mode.
+   * @param  aDependencies
+   *         An array of add-on IDs on which this add-on depends.
+   * @param  hasEmbeddedWebExtension
+   *         Boolean indicating whether the add-on has an embedded webextension.
+   * @return a JavaScript scope
+   */
+  loadBootstrapScope: function(aId, aFile, aVersion, aType,
+                               aMultiprocessCompatible, aRunInSafeMode,
+                               aDependencies, hasEmbeddedWebExtension) {
+    // Mark the add-on as active for the crash reporter before loading
+    this.bootstrappedAddons[aId] = {
+      version: aVersion,
+      type: aType,
+      descriptor: aFile.persistentDescriptor,
+      multiprocessCompatible: aMultiprocessCompatible,
+      runInSafeMode: aRunInSafeMode,
+      dependencies: aDependencies,
+      hasEmbeddedWebExtension,
+    };
+    this.persistBootstrappedAddons();
+    this.addAddonsToCrashReporter();
+
+    this.activeAddons.set(aId, {
+      debugGlobal: null,
+      safeWrapper: null,
+      bootstrapScope: null,
+      // a Symbol passed to this add-on, which it can use to identify itself
+      instanceID: Symbol(aId),
+    });
+    let activeAddon = this.activeAddons.get(aId);
+
+    // Locales only contain chrome and can't have bootstrap scripts
+    if (aType == "locale") {
+      return;
+    }
+
+    logger.debug("Loading bootstrap scope from " + aFile.path);
+
+    let principal = Cc["@mozilla.org/systemprincipal;1"].
+                    createInstance(Ci.nsIPrincipal);
+    if (!aMultiprocessCompatible && Preferences.get(PREF_INTERPOSITION_ENABLED, false)) {
+      let interposition = Cc["@mozilla.org/addons/multiprocess-shims;1"].
+        getService(Ci.nsIAddonInterposition);
+      Cu.setAddonInterposition(aId, interposition);
+      Cu.allowCPOWsInAddon(aId, true);
+    }
+
+    if (!aFile.exists()) {
+      activeAddon.bootstrapScope =
+        new Cu.Sandbox(principal, { sandboxName: aFile.path,
+                                    wantGlobalProperties: ["indexedDB"],
+                                    addonId: aId,
+                                    metadata: { addonID: aId } });
+      logger.error("Attempted to load bootstrap scope from missing directory " + aFile.path);
+      return;
+    }
+
+    let uri = getURIForResourceInFile(aFile, "bootstrap.js").spec;
+    if (aType == "dictionary")
+      uri = "resource://gre/modules/addons/SpellCheckDictionaryBootstrap.js"
+    else if (aType == "webextension")
+      uri = "resource://gre/modules/addons/WebExtensionBootstrap.js"
+    else if (aType == "apiextension")
+      uri = "resource://gre/modules/addons/APIExtensionBootstrap.js"
+
+    activeAddon.bootstrapScope =
+      new Cu.Sandbox(principal, { sandboxName: uri,
+                                  wantGlobalProperties: ["indexedDB"],
+                                  addonId: aId,
+                                  metadata: { addonID: aId, URI: uri } });
+
+    let loader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
+                 createInstance(Ci.mozIJSSubScriptLoader);
+
+    try {
+      // Copy the reason values from the global object into the bootstrap scope.
+      for (let name in BOOTSTRAP_REASONS)
+        activeAddon.bootstrapScope[name] = BOOTSTRAP_REASONS[name];
+
+      // Add other stuff that extensions want.
+      const features = [ "Worker", "ChromeWorker" ];
+
+      for (let feature of features)
+        activeAddon.bootstrapScope[feature] = gGlobalScope[feature];
+
+      // Define a console for the add-on
+      activeAddon.bootstrapScope["console"] = new ConsoleAPI(
+        { consoleID: "addon/" + aId });
+
+      // As we don't want our caller to control the JS version used for the
+      // bootstrap file, we run loadSubScript within the context of the
+      // sandbox with the latest JS version set explicitly.
+      activeAddon.bootstrapScope.__SCRIPT_URI_SPEC__ = uri;
+      Components.utils.evalInSandbox(
+        "Components.classes['@mozilla.org/moz/jssubscript-loader;1'] \
+                   .createInstance(Components.interfaces.mozIJSSubScriptLoader) \
+                   .loadSubScript(__SCRIPT_URI_SPEC__);",
+                   activeAddon.bootstrapScope, "ECMAv5");
+    }
+    catch (e) {
+      logger.warn("Error loading bootstrap.js for " + aId, e);
+    }
+
+    // Only access BrowserToolboxProcess if ToolboxProcess.jsm has been
+    // initialized as otherwise, when it will be initialized, all addons'
+    // globals will be added anyways
+    if (this._toolboxProcessLoaded) {
+      BrowserToolboxProcess.setAddonOptions(aId,
+        { global: activeAddon.bootstrapScope });
+    }
+  },
+
+  /**
+   * Unloads a bootstrap scope by dropping all references to it and then
+   * updating the list of active add-ons with the crash reporter.
+   *
+   * @param  aId
+   *         The add-on's ID
+   */
+  unloadBootstrapScope: function(aId) {
+    // In case the add-on was not multiprocess-compatible, deregister
+    // any interpositions for it.
+    Cu.setAddonInterposition(aId, null);
+    Cu.allowCPOWsInAddon(aId, false);
+
+    this.activeAddons.delete(aId);
+    delete this.bootstrappedAddons[aId];
+    this.persistBootstrappedAddons();
+    this.addAddonsToCrashReporter();
+
+    // Only access BrowserToolboxProcess if ToolboxProcess.jsm has been
+    // initialized as otherwise, there won't be any addon globals added to it
+    if (this._toolboxProcessLoaded) {
+      BrowserToolboxProcess.setAddonOptions(aId, { global: null });
+    }
+  },
+
+  /**
+   * Calls a bootstrap method for an add-on.
+   *
+   * @param  aAddon
+   *         An object representing the add-on, with `id`, `type` and `version`
+   * @param  aFile
+   *         The nsIFile for the add-on
+   * @param  aMethod
+   *         The name of the bootstrap method to call
+   * @param  aReason
+   *         The reason flag to pass to the bootstrap's startup method
+   * @param  aExtraParams
+   *         An object of additional key/value pairs to pass to the method in
+   *         the params argument
+   */
+  callBootstrapMethod: function(aAddon, aFile, aMethod, aReason, aExtraParams) {
+    if (!aAddon.id || !aAddon.version || !aAddon.type) {
+      throw new Error("aAddon must include an id, version, and type");
+    }
+
+    // Only run in safe mode if allowed to
+    let runInSafeMode = "runInSafeMode" in aAddon ? aAddon.runInSafeMode : canRunInSafeMode(aAddon);
+    if (Services.appinfo.inSafeMode && !runInSafeMode)
+      return;
+
+    let timeStart = new Date();
+    if (CHROME_TYPES.has(aAddon.type) && aMethod == "startup") {
+      logger.debug("Registering manifest for " + aFile.path);
+      Components.manager.addBootstrappedManifestLocation(aFile);
+    }
+
+    try {
+      // Load the scope if it hasn't already been loaded
+      let activeAddon = this.activeAddons.get(aAddon.id);
+      if (!activeAddon) {
+        this.loadBootstrapScope(aAddon.id, aFile, aAddon.version, aAddon.type,
+                                aAddon.multiprocessCompatible || false,
+                                runInSafeMode, aAddon.dependencies,
+                                aAddon.hasEmbeddedWebExtension || false);
+        activeAddon = this.activeAddons.get(aAddon.id);
+      }
+
+      if (aMethod == "startup" || aMethod == "shutdown") {
+        if (!aExtraParams) {
+          aExtraParams = {};
+        }
+        aExtraParams["instanceID"] = this.activeAddons.get(aAddon.id).instanceID;
+      }
+
+      // Nothing to call for locales
+      if (aAddon.type == "locale")
+        return;
+
+      let method = undefined;
+      try {
+        method = Components.utils.evalInSandbox(`${aMethod};`,
+          activeAddon.bootstrapScope, "ECMAv5");
+      }
+      catch (e) {
+        // An exception will be caught if the expected method is not defined.
+        // That will be logged below.
+      }
+
+      if (!method) {
+        logger.warn("Add-on " + aAddon.id + " is missing bootstrap method " + aMethod);
+        return;
+      }
+
+      // Extensions are automatically deinitialized in the correct order at shutdown.
+      if (aMethod == "shutdown" && aReason != BOOTSTRAP_REASONS.APP_SHUTDOWN) {
+        activeAddon.disable = true;
+        for (let addon of this.getDependentAddons(aAddon)) {
+          if (addon.active)
+            this.updateAddonDisabledState(addon);
+        }
+      }
+
+      let params = {
+        id: aAddon.id,
+        version: aAddon.version,
+        installPath: aFile.clone(),
+        resourceURI: getURIForResourceInFile(aFile, "")
+      };
+
+      if (aExtraParams) {
+        for (let key in aExtraParams) {
+          params[key] = aExtraParams[key];
+        }
+      }
+
+      if (aAddon.hasEmbeddedWebExtension) {
+        if (aMethod == "startup") {
+          const webExtension = LegacyExtensionsUtils.getEmbeddedExtensionFor(params);
+          params.webExtension = {
+            startup: () => webExtension.startup(),
+          };
+        } else if (aMethod == "shutdown") {
+          LegacyExtensionsUtils.getEmbeddedExtensionFor(params).shutdown();
+        }
+      }
+
+      logger.debug("Calling bootstrap method " + aMethod + " on " + aAddon.id + " version " +
+                   aAddon.version);
+      try {
+        method(params, aReason);
+      }
+      catch (e) {
+        logger.warn("Exception running bootstrap method " + aMethod + " on " + aAddon.id, e);
+      }
+    }
+    finally {
+      // Extensions are automatically initialized in the correct order at startup.
+      if (aMethod == "startup" && aReason != BOOTSTRAP_REASONS.APP_STARTUP) {
+        for (let addon of this.getDependentAddons(aAddon))
+          this.updateAddonDisabledState(addon);
+      }
+
+      if (CHROME_TYPES.has(aAddon.type) && aMethod == "shutdown" && aReason != BOOTSTRAP_REASONS.APP_SHUTDOWN) {
+        logger.debug("Removing manifest for " + aFile.path);
+        Components.manager.removeBootstrappedManifestLocation(aFile);
+
+        let manifest = getURIForResourceInFile(aFile, "chrome.manifest");
+        for (let line of ChromeManifestParser.parseSync(manifest)) {
+          if (line.type == "resource") {
+            ResProtocolHandler.setSubstitution(line.args[0], null);
+          }
+        }
+      }
+      this.setTelemetry(aAddon.id, aMethod + "_MS", new Date() - timeStart);
+    }
+  },
+
+  /**
+   * Updates the disabled state for an add-on. Its appDisabled property will be
+   * calculated and if the add-on is changed the database will be saved and
+   * appropriate notifications will be sent out to the registered AddonListeners.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal to update
+   * @param  aUserDisabled
+   *         Value for the userDisabled property. If undefined the value will
+   *         not change
+   * @param  aSoftDisabled
+   *         Value for the softDisabled property. If undefined the value will
+   *         not change. If true this will force userDisabled to be true
+   * @return a tri-state indicating the action taken for the add-on:
+   *           - undefined: The add-on did not change state
+   *           - true: The add-on because disabled
+   *           - false: The add-on became enabled
+   * @throws if addon is not a DBAddonInternal
+   */
+  updateAddonDisabledState: function(aAddon, aUserDisabled, aSoftDisabled) {
+    if (!(aAddon.inDatabase))
+      throw new Error("Can only update addon states for installed addons.");
+    if (aUserDisabled !== undefined && aSoftDisabled !== undefined) {
+      throw new Error("Cannot change userDisabled and softDisabled at the " +
+                      "same time");
+    }
+
+    if (aUserDisabled === undefined) {
+      aUserDisabled = aAddon.userDisabled;
+    }
+    else if (!aUserDisabled) {
+      // If enabling the add-on then remove softDisabled
+      aSoftDisabled = false;
+    }
+
+    // If not changing softDisabled or the add-on is already userDisabled then
+    // use the existing value for softDisabled
+    if (aSoftDisabled === undefined || aUserDisabled)
+      aSoftDisabled = aAddon.softDisabled;
+
+    let appDisabled = !isUsableAddon(aAddon);
+    // No change means nothing to do here
+    if (aAddon.userDisabled == aUserDisabled &&
+        aAddon.appDisabled == appDisabled &&
+        aAddon.softDisabled == aSoftDisabled)
+      return undefined;
+
+    let wasDisabled = aAddon.disabled;
+    let isDisabled = aUserDisabled || aSoftDisabled || appDisabled;
+
+    // If appDisabled changes but addon.disabled doesn't,
+    // no onDisabling/onEnabling is sent - so send a onPropertyChanged.
+    let appDisabledChanged = aAddon.appDisabled != appDisabled;
+
+    // Update the properties in the database.
+    XPIDatabase.setAddonProperties(aAddon, {
+      userDisabled: aUserDisabled,
+      appDisabled: appDisabled,
+      softDisabled: aSoftDisabled
+    });
+
+    let wrapper = aAddon.wrapper;
+
+    if (appDisabledChanged) {
+      AddonManagerPrivate.callAddonListeners("onPropertyChanged",
+                                             wrapper,
+                                             ["appDisabled"]);
+    }
+
+    // If the add-on is not visible or the add-on is not changing state then
+    // there is no need to do anything else
+    if (!aAddon.visible || (wasDisabled == isDisabled))
+      return undefined;
+
+    // Flag that active states in the database need to be updated on shutdown
+    Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+
+    // Have we just gone back to the current state?
+    if (isDisabled != aAddon.active) {
+      AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
+    }
+    else {
+      if (isDisabled) {
+        var needsRestart = this.disableRequiresRestart(aAddon);
+        AddonManagerPrivate.callAddonListeners("onDisabling", wrapper,
+                                               needsRestart);
+      }
+      else {
+        needsRestart = this.enableRequiresRestart(aAddon);
+        AddonManagerPrivate.callAddonListeners("onEnabling", wrapper,
+                                               needsRestart);
+      }
+
+      if (!needsRestart) {
+        XPIDatabase.updateAddonActive(aAddon, !isDisabled);
+
+        if (isDisabled) {
+          if (aAddon.bootstrap) {
+            this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown",
+                                     BOOTSTRAP_REASONS.ADDON_DISABLE);
+            this.unloadBootstrapScope(aAddon.id);
+          }
+          AddonManagerPrivate.callAddonListeners("onDisabled", wrapper);
+        }
+        else {
+          if (aAddon.bootstrap) {
+            this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "startup",
+                                     BOOTSTRAP_REASONS.ADDON_ENABLE);
+          }
+          AddonManagerPrivate.callAddonListeners("onEnabled", wrapper);
+        }
+      }
+      else if (aAddon.bootstrap) {
+        // Something blocked the restartless add-on from enabling or disabling
+        // make sure it happens on the next startup
+        if (isDisabled) {
+          this.bootstrappedAddons[aAddon.id].disable = true;
+        }
+        else {
+          this.bootstrappedAddons[aAddon.id] = {
+            version: aAddon.version,
+            type: aAddon.type,
+            descriptor: aAddon._sourceBundle.persistentDescriptor,
+            multiprocessCompatible: aAddon.multiprocessCompatible,
+            runInSafeMode: canRunInSafeMode(aAddon),
+            dependencies: aAddon.dependencies,
+            hasEmbeddedWebExtension: aAddon.hasEmbeddedWebExtension,
+          };
+          this.persistBootstrappedAddons();
+        }
+      }
+    }
+
+    // Sync with XPIStates.
+    let xpiState = XPIStates.getAddon(aAddon.location, aAddon.id);
+    if (xpiState) {
+      xpiState.syncWithDB(aAddon);
+      XPIStates.save();
+    } else {
+      // There should always be an xpiState
+      logger.warn("No XPIState for ${id} in ${location}", aAddon);
+    }
+
+    // Notify any other providers that a new theme has been enabled
+    if (aAddon.type == "theme" && !isDisabled)
+      AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, needsRestart);
+
+    return isDisabled;
+  },
+
+  /**
+   * Uninstalls an add-on, immediately if possible or marks it as pending
+   * uninstall if not.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal to uninstall
+   * @param  aForcePending
+   *         Force this addon into the pending uninstall state, even if
+   *         it isn't marked as requiring a restart (used e.g. while the
+   *         add-on manager is open and offering an "undo" button)
+   * @throws if the addon cannot be uninstalled because it is in an install
+   *         location that does not allow it
+   */
+  uninstallAddon: function(aAddon, aForcePending) {
+    if (!(aAddon.inDatabase))
+      throw new Error("Cannot uninstall addon " + aAddon.id + " because it is not installed");
+
+    if (aAddon._installLocation.locked)
+      throw new Error("Cannot uninstall addon " + aAddon.id
+          + " from locked install location " + aAddon._installLocation.name);
+
+    // Inactive add-ons don't require a restart to uninstall
+    let requiresRestart = this.uninstallRequiresRestart(aAddon);
+
+    // if makePending is true, we don't actually apply the uninstall,
+    // we just mark the addon as having a pending uninstall
+    let makePending = aForcePending || requiresRestart;
+
+    if (makePending && aAddon.pendingUninstall)
+      throw new Error("Add-on is already marked to be uninstalled");
+
+    aAddon._hasResourceCache.clear();
+
+    if (aAddon._updateCheck) {
+      logger.debug("Cancel in-progress update check for " + aAddon.id);
+      aAddon._updateCheck.cancel();
+    }
+
+    let wasPending = aAddon.pendingUninstall;
+
+    if (makePending) {
+      // We create an empty directory in the staging directory to indicate
+      // that an uninstall is necessary on next startup. Temporary add-ons are
+      // automatically uninstalled on shutdown anyway so there is no need to
+      // do this for them.
+      if (aAddon._installLocation.name != KEY_APP_TEMPORARY) {
+        let stage = aAddon._installLocation.getStagingDir();
+        stage.append(aAddon.id);
+        if (!stage.exists())
+          stage.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+      }
+
+      XPIDatabase.setAddonProperties(aAddon, {
+        pendingUninstall: true
+      });
+      Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+      let xpiState = XPIStates.getAddon(aAddon.location, aAddon.id);
+      if (xpiState) {
+        xpiState.enabled = false;
+        XPIStates.save();
+      } else {
+        logger.warn("Can't find XPI state while uninstalling ${id} from ${location}", aAddon);
+      }
+    }
+
+    // If the add-on is not visible then there is no need to notify listeners.
+    if (!aAddon.visible)
+      return;
+
+    let wrapper = aAddon.wrapper;
+
+    // If the add-on wasn't already pending uninstall then notify listeners.
+    if (!wasPending) {
+      // Passing makePending as the requiresRestart parameter is a little
+      // strange as in some cases this operation can complete without a restart
+      // so really this is now saying that the uninstall isn't going to happen
+      // immediately but will happen later.
+      AddonManagerPrivate.callAddonListeners("onUninstalling", wrapper,
+                                             makePending);
+    }
+
+    // Reveal the highest priority add-on with the same ID
+    function revealAddon(aAddon) {
+      XPIDatabase.makeAddonVisible(aAddon);
+
+      let wrappedAddon = aAddon.wrapper;
+      AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false);
+
+      if (!aAddon.disabled && !XPIProvider.enableRequiresRestart(aAddon)) {
+        XPIDatabase.updateAddonActive(aAddon, true);
+      }
+
+      if (aAddon.bootstrap) {
+        XPIProvider.callBootstrapMethod(aAddon, aAddon._sourceBundle,
+                                        "install", BOOTSTRAP_REASONS.ADDON_INSTALL);
+
+        if (aAddon.active) {
+          XPIProvider.callBootstrapMethod(aAddon, aAddon._sourceBundle,
+                                          "startup", BOOTSTRAP_REASONS.ADDON_INSTALL);
+        }
+        else {
+          XPIProvider.unloadBootstrapScope(aAddon.id);
+        }
+      }
+
+      // We always send onInstalled even if a restart is required to enable
+      // the revealed add-on
+      AddonManagerPrivate.callAddonListeners("onInstalled", wrappedAddon);
+    }
+
+    function findAddonAndReveal(aId) {
+      let [locationName, ] = XPIStates.findAddon(aId);
+      if (locationName) {
+        XPIDatabase.getAddonInLocation(aId, locationName, revealAddon);
+      }
+    }
+
+    if (!makePending) {
+      if (aAddon.bootstrap) {
+        if (aAddon.active) {
+          this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown",
+                                   BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+        }
+
+        this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "uninstall",
+                                 BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+        this.unloadBootstrapScope(aAddon.id);
+        flushChromeCaches();
+      }
+      aAddon._installLocation.uninstallAddon(aAddon.id);
+      XPIDatabase.removeAddonMetadata(aAddon);
+      XPIStates.removeAddon(aAddon.location, aAddon.id);
+      AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);
+
+      findAddonAndReveal(aAddon.id);
+    }
+    else if (aAddon.bootstrap && aAddon.active && !this.disableRequiresRestart(aAddon)) {
+      this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown",
+                               BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+      this.unloadBootstrapScope(aAddon.id);
+      XPIDatabase.updateAddonActive(aAddon, false);
+    }
+
+    // Notify any other providers that a new theme has been enabled
+    if (aAddon.type == "theme" && aAddon.active)
+      AddonManagerPrivate.notifyAddonChanged(null, aAddon.type, requiresRestart);
+  },
+
+  /**
+   * Cancels the pending uninstall of an add-on.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal to cancel uninstall for
+   */
+  cancelUninstallAddon: function(aAddon) {
+    if (!(aAddon.inDatabase))
+      throw new Error("Can only cancel uninstall for installed addons.");
+    if (!aAddon.pendingUninstall)
+      throw new Error("Add-on is not marked to be uninstalled");
+
+    if (aAddon._installLocation.name != KEY_APP_TEMPORARY)
+      aAddon._installLocation.cleanStagingDir([aAddon.id]);
+
+    XPIDatabase.setAddonProperties(aAddon, {
+      pendingUninstall: false
+    });
+
+    if (!aAddon.visible)
+      return;
+
+    Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+
+    // TODO hide hidden add-ons (bug 557710)
+    let wrapper = aAddon.wrapper;
+    AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
+
+    if (aAddon.bootstrap && !aAddon.disabled && !this.enableRequiresRestart(aAddon)) {
+      this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "startup",
+                               BOOTSTRAP_REASONS.ADDON_INSTALL);
+      XPIDatabase.updateAddonActive(aAddon, true);
+    }
+
+    // Notify any other providers that this theme is now enabled again.
+    if (aAddon.type == "theme" && aAddon.active)
+      AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, false);
+  }
+};
+
+function getHashStringForCrypto(aCrypto) {
+  // return the two-digit hexadecimal code for a byte
+  let toHexString = charCode => ("0" + charCode.toString(16)).slice(-2);
+
+  // convert the binary hash data to a hex string.
+  let binary = aCrypto.finish(false);
+  let hash = Array.from(binary, c => toHexString(c.charCodeAt(0)))
+  return hash.join("").toLowerCase();
+}
+
+/**
+ * Base class for objects that manage the installation of an addon.
+ * This class isn't instantiated directly, see the derived classes below.
+ */
+class AddonInstall {
+  /**
+   * Instantiates an AddonInstall.
+   *
+   * @param  aInstallLocation
+   *         The install location the add-on will be installed into
+   * @param  aUrl
+   *         The nsIURL to get the add-on from. If this is an nsIFileURL then
+   *         the add-on will not need to be downloaded
+   * @param  aHash
+   *         An optional hash for the add-on
+   * @param  aExistingAddon
+   *         The add-on this install will update if known
+   */
+  constructor(aInstallLocation, aUrl, aHash, aExistingAddon) {
+    this.wrapper = new AddonInstallWrapper(this);
+    this.installLocation = aInstallLocation;
+    this.sourceURI = aUrl;
+
+    if (aHash) {
+      let hashSplit = aHash.toLowerCase().split(":");
+      this.originalHash = {
+        algorithm: hashSplit[0],
+        data: hashSplit[1]
+      };
+    }
+    this.hash = this.originalHash;
+    this.existingAddon = aExistingAddon;
+    this.releaseNotesURI = null;
+
+    this.listeners = [];
+    this.icons = {};
+    this.error = 0;
+
+    this.progress = 0;
+    this.maxProgress = -1;
+
+    // Giving each instance of AddonInstall a reference to the logger.
+    this.logger = logger;
+
+    this.name = null;
+    this.type = null;
+    this.version = null;
+
+    this.file = null;
+    this.ownsTempFile = null;
+    this.certificate = null;
+    this.certName = null;
+
+    this.linkedInstalls = null;
+    this.addon = null;
+    this.state = null;
+
+    XPIProvider.installs.add(this);
+  }
+
+  /**
+   * Starts installation of this add-on from whatever state it is currently at
+   * if possible.
+   *
+   * Note this method is overridden to handle additional state in
+   * the subclassses below.
+   *
+   * @throws if installation cannot proceed from the current state
+   */
+  install() {
+    switch (this.state) {
+    case AddonManager.STATE_DOWNLOADED:
+      this.startInstall();
+      break;
+    case AddonManager.STATE_POSTPONED:
+      logger.debug(`Postponing install of ${this.addon.id}`);
+      break;
+    case AddonManager.STATE_DOWNLOADING:
+    case AddonManager.STATE_CHECKING:
+    case AddonManager.STATE_INSTALLING:
+      // Installation is already running
+      return;
+    default:
+      throw new Error("Cannot start installing from this state");
+    }
+  }
+
+  /**
+   * Cancels installation of this add-on.
+   *
+   * Note this method is overridden to handle additional state in
+   * the subclass DownloadAddonInstall.
+   *
+   * @throws if installation cannot be cancelled from the current state
+   */
+  cancel() {
+    switch (this.state) {
+    case AddonManager.STATE_AVAILABLE:
+    case AddonManager.STATE_DOWNLOADED:
+      logger.debug("Cancelling download of " + this.sourceURI.spec);
+      this.state = AddonManager.STATE_CANCELLED;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
+                                               this.listeners, this.wrapper);
+      this.removeTemporaryFile();
+      break;
+    case AddonManager.STATE_INSTALLED:
+      logger.debug("Cancelling install of " + this.addon.id);
+      let xpi = this.installLocation.getStagingDir();
+      xpi.append(this.addon.id + ".xpi");
+      flushJarCache(xpi);
+      this.installLocation.cleanStagingDir([this.addon.id, this.addon.id + ".xpi",
+                                            this.addon.id + ".json"]);
+      this.state = AddonManager.STATE_CANCELLED;
+      XPIProvider.removeActiveInstall(this);
+
+      if (this.existingAddon) {
+        delete this.existingAddon.pendingUpgrade;
+        this.existingAddon.pendingUpgrade = null;
+      }
+
+      AddonManagerPrivate.callAddonListeners("onOperationCancelled", this.addon.wrapper);
+
+      AddonManagerPrivate.callInstallListeners("onInstallCancelled",
+                                               this.listeners, this.wrapper);
+      break;
+    case AddonManager.STATE_POSTPONED:
+      logger.debug(`Cancelling postponed install of ${this.addon.id}`);
+      this.state = AddonManager.STATE_CANCELLED;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onInstallCancelled",
+                                               this.listeners, this.wrapper);
+      this.removeTemporaryFile();
+
+      let stagingDir = this.installLocation.getStagingDir();
+      let stagedAddon = stagingDir.clone();
+
+      this.unstageInstall(stagedAddon);
+    default:
+      throw new Error("Cannot cancel install of " + this.sourceURI.spec +
+                      " from this state (" + this.state + ")");
+    }
+  }
+
+  /**
+   * Adds an InstallListener for this instance if the listener is not already
+   * registered.
+   *
+   * @param  aListener
+   *         The InstallListener to add
+   */
+  addListener(aListener) {
+    if (!this.listeners.some(function(i) { return i == aListener; }))
+      this.listeners.push(aListener);
+  }
+
+  /**
+   * Removes an InstallListener for this instance if it is registered.
+   *
+   * @param  aListener
+   *         The InstallListener to remove
+   */
+  removeListener(aListener) {
+    this.listeners = this.listeners.filter(function(i) {
+      return i != aListener;
+    });
+  }
+
+  /**
+   * Removes the temporary file owned by this AddonInstall if there is one.
+   */
+  removeTemporaryFile() {
+    // Only proceed if this AddonInstall owns its XPI file
+    if (!this.ownsTempFile) {
+      this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " does not own temp file");
+      return;
+    }
+
+    try {
+      this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " removing temp file " +
+          this.file.path);
+      this.file.remove(true);
+      this.ownsTempFile = false;
+    }
+    catch (e) {
+      this.logger.warn("Failed to remove temporary file " + this.file.path + " for addon " +
+          this.sourceURI.spec,
+          e);
+    }
+  }
+
+  /**
+   * Updates the sourceURI and releaseNotesURI values on the Addon being
+   * installed by this AddonInstall instance.
+   */
+  updateAddonURIs() {
+    this.addon.sourceURI = this.sourceURI.spec;
+    if (this.releaseNotesURI)
+      this.addon.releaseNotesURI = this.releaseNotesURI.spec;
+  }
+
+  /**
+   * Fills out linkedInstalls with AddonInstall instances for the other files
+   * in a multi-package XPI.
+   *
+   * @param  aFiles
+   *         An array of { entryName, file } for each remaining file from the
+   *         multi-package XPI.
+   */
+  _createLinkedInstalls(aFiles) {
+    return Task.spawn((function*() {
+      if (aFiles.length == 0)
+        return;
+
+      // Create new AddonInstall instances for every remaining file
+      if (!this.linkedInstalls)
+        this.linkedInstalls = [];
+
+      for (let { entryName, file } of aFiles) {
+        logger.debug("Creating linked install from " + entryName);
+        let install = yield createLocalInstall(file);
+
+        // Make the new install own its temporary file
+        install.ownsTempFile = true;
+
+        this.linkedInstalls.push(install);
+
+        // If one of the internal XPIs was multipackage then move its linked
+        // installs to the outer install
+        if (install.linkedInstalls) {
+          this.linkedInstalls.push(...install.linkedInstalls);
+          install.linkedInstalls = null;
+        }
+
+        install.sourceURI = this.sourceURI;
+        install.releaseNotesURI = this.releaseNotesURI;
+        if (install.state != AddonManager.STATE_DOWNLOAD_FAILED)
+          install.updateAddonURIs();
+      }
+    }).bind(this));
+  }
+
+  /**
+   * Loads add-on manifests from a multi-package XPI file. Each of the
+   * XPI and JAR files contained in the XPI will be extracted. Any that
+   * do not contain valid add-ons will be ignored. The first valid add-on will
+   * be installed by this AddonInstall instance, the rest will have new
+   * AddonInstall instances created for them.
+   *
+   * @param  aZipReader
+   *         An open nsIZipReader for the multi-package XPI's files. This will
+   *         be closed before this method returns.
+   */
+  _loadMultipackageManifests(aZipReader) {
+    return Task.spawn((function*() {
+      let files = [];
+      let entries = aZipReader.findEntries("(*.[Xx][Pp][Ii]|*.[Jj][Aa][Rr])");
+      while (entries.hasMore()) {
+        let entryName = entries.getNext();
+        let file = getTemporaryFile();
+        try {
+          aZipReader.extract(entryName, file);
+          files.push({ entryName, file });
+        }
+        catch (e) {
+          logger.warn("Failed to extract " + entryName + " from multi-package " +
+                      "XPI", e);
+          file.remove(false);
+        }
+      }
+
+      aZipReader.close();
+
+      if (files.length == 0) {
+        return Promise.reject([AddonManager.ERROR_CORRUPT_FILE,
+                               "Multi-package XPI does not contain any packages to install"]);
+      }
+
+      let addon = null;
+
+      // Find the first file that is a valid install and use it for
+      // the add-on that this AddonInstall instance will install.
+      for (let { entryName, file } of files) {
+        this.removeTemporaryFile();
+        try {
+          yield this.loadManifest(file);
+          logger.debug("Base multi-package XPI install came from " + entryName);
+          this.file = file;
+          this.ownsTempFile = true;
+
+          yield this._createLinkedInstalls(files.filter(f => f.file != file));
+          return undefined;
+        }
+        catch (e) {
+          // _createLinkedInstalls will log errors when it tries to process this
+          // file
+        }
+      }
+
+      // No valid add-on was found, delete all the temporary files
+      for (let { file } of files) {
+        try {
+          file.remove(true);
+        } catch (e) {
+          this.logger.warn("Could not remove temp file " + file.path);
+        }
+      }
+
+      return Promise.reject([AddonManager.ERROR_CORRUPT_FILE,
+                             "Multi-package XPI does not contain any valid packages to install"]);
+    }).bind(this));
+  }
+
+  /**
+   * Called after the add-on is a local file and the signature and install
+   * manifest can be read.
+   *
+   * @param  aCallback
+   *         A function to call when the manifest has been loaded
+   * @throws if the add-on does not contain a valid install manifest or the
+   *         XPI is incorrectly signed
+   */
+  loadManifest(file) {
+    return Task.spawn((function*() {
+      let zipreader = Cc["@mozilla.org/libjar/zip-reader;1"].
+          createInstance(Ci.nsIZipReader);
+      try {
+        zipreader.open(file);
+      }
+      catch (e) {
+        zipreader.close();
+        return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]);
+      }
+
+      try {
+        // loadManifestFromZipReader performs the certificate verification for us
+        this.addon = yield loadManifestFromZipReader(zipreader, this.installLocation);
+      }
+      catch (e) {
+        zipreader.close();
+        return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]);
+      }
+
+      // A multi-package XPI is a container, the add-ons it holds each
+      // have their own id.  Everything else had better have an id here.
+      if (!this.addon.id && this.addon.type != "multipackage") {
+        let err = new Error(`Cannot find id for addon ${file.path}`);
+        return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, err]);
+      }
+
+      if (this.existingAddon) {
+        // Check various conditions related to upgrades
+        if (this.addon.id != this.existingAddon.id) {
+          zipreader.close();
+          return Promise.reject([AddonManager.ERROR_INCORRECT_ID,
+                                 `Refusing to upgrade addon ${this.existingAddon.id} to different ID {this.addon.id}`]);
+        }
+
+        if (this.addon.type == "multipackage") {
+          zipreader.close();
+          return Promise.reject([AddonManager.ERROR_UNEXPECTED_ADDON_TYPE,
+                                 `Refusing to upgrade addon ${this.existingAddon.id} to a multi-package xpi`]);
+        }
+
+        if (this.existingAddon.type == "webextension" && this.addon.type != "webextension") {
+          zipreader.close();
+          return Promise.reject([AddonManager.ERROR_UNEXPECTED_ADDON_TYPE,
+                                 "WebExtensions may not be upated to other extension types"]);
+        }
+      }
+
+      if (mustSign(this.addon.type)) {
+        if (this.addon.signedState <= AddonManager.SIGNEDSTATE_MISSING) {
+          // This add-on isn't properly signed by a signature that chains to the
+          // trusted root.
+          let state = this.addon.signedState;
+          this.addon = null;
+          zipreader.close();
+
+          if (state == AddonManager.SIGNEDSTATE_MISSING)
+            return Promise.reject([AddonManager.ERROR_SIGNEDSTATE_REQUIRED,
+                                   "signature is required but missing"])
+
+          return Promise.reject([AddonManager.ERROR_CORRUPT_FILE,
+                                 "signature verification failed"])
+        }
+      }
+      else if (this.addon.signedState == AddonManager.SIGNEDSTATE_UNKNOWN ||
+               this.addon.signedState == AddonManager.SIGNEDSTATE_NOT_REQUIRED) {
+        // Check object signing certificate, if any
+        let x509 = zipreader.getSigningCert(null);
+        if (x509) {
+          logger.debug("Verifying XPI signature");
+          if (verifyZipSigning(zipreader, x509)) {
+            this.certificate = x509;
+            if (this.certificate.commonName.length > 0) {
+              this.certName = this.certificate.commonName;
+            } else {
+              this.certName = this.certificate.organization;
+            }
+          } else {
+            zipreader.close();
+            return Promise.reject([AddonManager.ERROR_CORRUPT_FILE,
+                                   "XPI is incorrectly signed"]);
+          }
+        }
+      }
+
+      if (this.addon.type == "multipackage")
+        return this._loadMultipackageManifests(zipreader);
+
+      zipreader.close();
+
+      this.updateAddonURIs();
+
+      this.addon._install = this;
+      this.name = this.addon.selectedLocale.name;
+      this.type = this.addon.type;
+      this.version = this.addon.version;
+
+      // Setting the iconURL to something inside the XPI locks the XPI and
+      // makes it impossible to delete on Windows.
+
+      // Try to load from the existing cache first
+      let repoAddon = yield new Promise(resolve => AddonRepository.getCachedAddonByID(this.addon.id, resolve));
+
+      // It wasn't there so try to re-download it
+      if (!repoAddon) {
+        yield new Promise(resolve => AddonRepository.cacheAddons([this.addon.id], resolve));
+        repoAddon = yield new Promise(resolve => AddonRepository.getCachedAddonByID(this.addon.id, resolve));
+      }
+
+      this.addon._repositoryAddon = repoAddon;
+      this.name = this.name || this.addon._repositoryAddon.name;
+      this.addon.compatibilityOverrides = repoAddon ?
+        repoAddon.compatibilityOverrides :
+        null;
+      this.addon.appDisabled = !isUsableAddon(this.addon);
+      return undefined;
+    }).bind(this));
+  }
+
+  // TODO This relies on the assumption that we are always installing into the
+  // highest priority install location so the resulting add-on will be visible
+  // overriding any existing copy in another install location (bug 557710).
+  /**
+   * Installs the add-on into the install location.
+   */
+  startInstall() {
+    this.state = AddonManager.STATE_INSTALLING;
+    if (!AddonManagerPrivate.callInstallListeners("onInstallStarted",
+                                                  this.listeners, this.wrapper)) {
+      this.state = AddonManager.STATE_DOWNLOADED;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onInstallCancelled",
+                                               this.listeners, this.wrapper)
+      return;
+    }
+
+    // Find and cancel any pending installs for the same add-on in the same
+    // install location
+    for (let aInstall of XPIProvider.installs) {
+      if (aInstall.state == AddonManager.STATE_INSTALLED &&
+          aInstall.installLocation == this.installLocation &&
+          aInstall.addon.id == this.addon.id) {
+        logger.debug("Cancelling previous pending install of " + aInstall.addon.id);
+        aInstall.cancel();
+      }
+    }
+
+    let isUpgrade = this.existingAddon &&
+                    this.existingAddon._installLocation == this.installLocation;
+    let requiresRestart = XPIProvider.installRequiresRestart(this.addon);
+
+    logger.debug("Starting install of " + this.addon.id + " from " + this.sourceURI.spec);
+    AddonManagerPrivate.callAddonListeners("onInstalling",
+                                           this.addon.wrapper,
+                                           requiresRestart);
+
+    let stagedAddon = this.installLocation.getStagingDir();
+
+    Task.spawn((function*() {
+      let installedUnpacked = 0;
+
+      yield this.installLocation.requestStagingDir();
+
+      // remove any previously staged files
+      yield this.unstageInstall(stagedAddon);
+
+      stagedAddon.append(this.addon.id);
+      stagedAddon.leafName = this.addon.id + ".xpi";
+
+      installedUnpacked = yield this.stageInstall(requiresRestart, stagedAddon, isUpgrade);
+
+      if (requiresRestart) {
+        this.state = AddonManager.STATE_INSTALLED;
+        AddonManagerPrivate.callInstallListeners("onInstallEnded",
+                                                 this.listeners, this.wrapper,
+                                                 this.addon.wrapper);
+      }
+      else {
+        // The install is completed so it should be removed from the active list
+        XPIProvider.removeActiveInstall(this);
+
+        // Deactivate and remove the old add-on as necessary
+        let reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
+        if (this.existingAddon) {
+          if (Services.vc.compare(this.existingAddon.version, this.addon.version) < 0)
+            reason = BOOTSTRAP_REASONS.ADDON_UPGRADE;
+          else
+            reason = BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
+
+          if (this.existingAddon.bootstrap) {
+            let file = this.existingAddon._sourceBundle;
+            if (this.existingAddon.active) {
+              XPIProvider.callBootstrapMethod(this.existingAddon, file,
+                                              "shutdown", reason,
+                                              { newVersion: this.addon.version });
+            }
+
+            XPIProvider.callBootstrapMethod(this.existingAddon, file,
+                                            "uninstall", reason,
+                                            { newVersion: this.addon.version });
+            XPIProvider.unloadBootstrapScope(this.existingAddon.id);
+            flushChromeCaches();
+          }
+
+          if (!isUpgrade && this.existingAddon.active) {
+            XPIDatabase.updateAddonActive(this.existingAddon, false);
+          }
+        }
+
+        // Install the new add-on into its final location
+        let existingAddonID = this.existingAddon ? this.existingAddon.id : null;
+        let file = this.installLocation.installAddon({
+          id: this.addon.id,
+          source: stagedAddon,
+          existingAddonID
+        });
+
+        // Update the metadata in the database
+        this.addon._sourceBundle = file;
+        this.addon.visible = true;
+
+        if (isUpgrade) {
+          this.addon =  XPIDatabase.updateAddonMetadata(this.existingAddon, this.addon,
+                                                        file.persistentDescriptor);
+          let state = XPIStates.getAddon(this.installLocation.name, this.addon.id);
+          if (state) {
+            state.syncWithDB(this.addon, true);
+          } else {
+            logger.warn("Unexpected missing XPI state for add-on ${id}", this.addon);
+          }
+        }
+        else {
+          this.addon.active = (this.addon.visible && !this.addon.disabled);
+          this.addon = XPIDatabase.addAddonMetadata(this.addon, file.persistentDescriptor);
+          XPIStates.addAddon(this.addon);
+          this.addon.installDate = this.addon.updateDate;
+          XPIDatabase.saveChanges();
+        }
+        XPIStates.save();
+
+        let extraParams = {};
+        if (this.existingAddon) {
+          extraParams.oldVersion = this.existingAddon.version;
+        }
+
+        if (this.addon.bootstrap) {
+          XPIProvider.callBootstrapMethod(this.addon, file, "install",
+                                          reason, extraParams);
+        }
+
+        AddonManagerPrivate.callAddonListeners("onInstalled",
+                                               this.addon.wrapper);
+
+        logger.debug("Install of " + this.sourceURI.spec + " completed.");
+        this.state = AddonManager.STATE_INSTALLED;
+        AddonManagerPrivate.callInstallListeners("onInstallEnded",
+                                                 this.listeners, this.wrapper,
+                                                 this.addon.wrapper);
+
+        if (this.addon.bootstrap) {
+          if (this.addon.active) {
+            XPIProvider.callBootstrapMethod(this.addon, file, "startup",
+                                            reason, extraParams);
+          }
+          else {
+            // XXX this makes it dangerous to do some things in onInstallEnded
+            // listeners because important cleanup hasn't been done yet
+            XPIProvider.unloadBootstrapScope(this.addon.id);
+          }
+        }
+        XPIProvider.setTelemetry(this.addon.id, "unpacked", installedUnpacked);
+        recordAddonTelemetry(this.addon);
+      }
+    }).bind(this)).then(null, (e) => {
+      logger.warn(`Failed to install ${this.file.path} from ${this.sourceURI.spec} to ${stagedAddon.path}`, e);
+
+      if (stagedAddon.exists())
+        recursiveRemove(stagedAddon);
+      this.state = AddonManager.STATE_INSTALL_FAILED;
+      this.error = AddonManager.ERROR_FILE_ACCESS;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callAddonListeners("onOperationCancelled",
+                                             this.addon.wrapper);
+      AddonManagerPrivate.callInstallListeners("onInstallFailed",
+                                               this.listeners,
+                                               this.wrapper);
+    }).then(() => {
+      this.removeTemporaryFile();
+      return this.installLocation.releaseStagingDir();
+    });
+  }
+
+  /**
+   * Stages an upgrade for next application restart.
+   */
+  stageInstall(restartRequired, stagedAddon, isUpgrade) {
+    return Task.spawn((function*() {
+      let stagedJSON = stagedAddon.clone();
+      stagedJSON.leafName = this.addon.id + ".json";
+
+      let installedUnpacked = 0;
+
+      // First stage the file regardless of whether restarting is necessary
+      if (this.addon.unpack || Preferences.get(PREF_XPI_UNPACK, false)) {
+        logger.debug("Addon " + this.addon.id + " will be installed as " +
+                     "an unpacked directory");
+        stagedAddon.leafName = this.addon.id;
+        yield OS.File.makeDir(stagedAddon.path);
+        yield ZipUtils.extractFilesAsync(this.file, stagedAddon);
+        installedUnpacked = 1;
+      }
+      else {
+        logger.debug(`Addon ${this.addon.id} will be installed as a packed xpi`);
+        stagedAddon.leafName = this.addon.id + ".xpi";
+
+        yield OS.File.copy(this.file.path, stagedAddon.path);
+      }
+
+      if (restartRequired) {
+        // Point the add-on to its extracted files as the xpi may get deleted
+        this.addon._sourceBundle = stagedAddon;
+
+        // Cache the AddonInternal as it may have updated compatibility info
+        writeStringToFile(stagedJSON, JSON.stringify(this.addon));
+
+        logger.debug("Staged install of " + this.addon.id + " from " + this.sourceURI.spec + " ready; waiting for restart.");
+        if (isUpgrade) {
+          delete this.existingAddon.pendingUpgrade;
+          this.existingAddon.pendingUpgrade = this.addon;
+        }
+      }
+
+      return installedUnpacked;
+    }).bind(this));
+  }
+
+  /**
+   * Removes any previously staged upgrade.
+   */
+  unstageInstall(stagedAddon) {
+    return Task.spawn((function*() {
+      let stagedJSON = stagedAddon.clone();
+      let removedAddon = stagedAddon.clone();
+
+      stagedJSON.append(this.addon.id + ".json");
+
+      if (stagedJSON.exists()) {
+        stagedJSON.remove(true);
+      }
+
+      removedAddon.append(this.addon.id);
+      yield removeAsync(removedAddon);
+      removedAddon.leafName = this.addon.id + ".xpi";
+      yield removeAsync(removedAddon);
+    }).bind(this));
+  }
+
+  /**
+    * Postone a pending update, until restart or until the add-on resumes.
+    *
+    * @param {Function} resumeFunction - a function for the add-on to run
+    *                                    when resuming.
+    */
+  postpone(resumeFunction) {
+    return Task.spawn((function*() {
+      this.state = AddonManager.STATE_POSTPONED;
+
+      let stagingDir = this.installLocation.getStagingDir();
+      let stagedAddon = stagingDir.clone();
+
+      yield this.installLocation.requestStagingDir();
+      yield this.unstageInstall(stagedAddon);
+
+      stagedAddon.append(this.addon.id);
+      stagedAddon.leafName = this.addon.id + ".xpi";
+
+      yield this.stageInstall(true, stagedAddon, true);
+
+      AddonManagerPrivate.callInstallListeners("onInstallPostponed",
+                                               this.listeners, this.wrapper)
+
+      // upgrade has been staged for restart, provide a way for it to call the
+      // resume function.
+      if (resumeFunction) {
+        let callback = AddonManagerPrivate.getUpgradeListener(this.addon.id);
+        if (callback) {
+          callback({
+            version: this.version,
+            install: () => {
+              switch (this.state) {
+              case AddonManager.STATE_POSTPONED:
+                resumeFunction();
+                break;
+              default:
+                logger.warn(`${this.addon.id} cannot resume postponed upgrade from state (${this.state})`);
+                break;
+              }
+            },
+          });
+        }
+      }
+      this.installLocation.releaseStagingDir();
+    }).bind(this));
+  }
+}
+
+class LocalAddonInstall extends AddonInstall {
+  /**
+   * Initialises this install to be an install from a local file.
+   *
+   * @returns Promise
+   *          A Promise that resolves when the object is ready to use.
+   */
+  init() {
+    return Task.spawn((function*() {
+      this.file = this.sourceURI.QueryInterface(Ci.nsIFileURL).file;
+
+      if (!this.file.exists()) {
+        logger.warn("XPI file " + this.file.path + " does not exist");
+        this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+        this.error = AddonManager.ERROR_NETWORK_FAILURE;
+        XPIProvider.removeActiveInstall(this);
+        return;
+      }
+
+      this.state = AddonManager.STATE_DOWNLOADED;
+      this.progress = this.file.fileSize;
+      this.maxProgress = this.file.fileSize;
+
+      if (this.hash) {
+        let crypto = Cc["@mozilla.org/security/hash;1"].
+            createInstance(Ci.nsICryptoHash);
+        try {
+          crypto.initWithString(this.hash.algorithm);
+        }
+        catch (e) {
+          logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
+          this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+          this.error = AddonManager.ERROR_INCORRECT_HASH;
+          XPIProvider.removeActiveInstall(this);
+          return;
+        }
+
+        let fis = Cc["@mozilla.org/network/file-input-stream;1"].
+            createInstance(Ci.nsIFileInputStream);
+        fis.init(this.file, -1, -1, false);
+        crypto.updateFromStream(fis, this.file.fileSize);
+        let calculatedHash = getHashStringForCrypto(crypto);
+        if (calculatedHash != this.hash.data) {
+          logger.warn("File hash (" + calculatedHash + ") did not match provided hash (" +
+                      this.hash.data + ")");
+          this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+          this.error = AddonManager.ERROR_INCORRECT_HASH;
+          XPIProvider.removeActiveInstall(this);
+          return;
+        }
+      }
+
+      try {
+        yield this.loadManifest(this.file);
+      } catch ([error, message]) {
+        logger.warn("Invalid XPI", message);
+        this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+        this.error = error;
+        XPIProvider.removeActiveInstall(this);
+        AddonManagerPrivate.callInstallListeners("onNewInstall",
+                                                 this.listeners,
+                                                 this.wrapper);
+        return;
+      }
+
+      let addon = yield new Promise(resolve => {
+        XPIDatabase.getVisibleAddonForID(this.addon.id, resolve);
+      });
+
+      this.existingAddon = addon;
+      if (addon)
+        applyBlocklistChanges(addon, this.addon);
+      this.addon.updateDate = Date.now();
+      this.addon.installDate = addon ? addon.installDate : this.addon.updateDate;
+
+      if (!this.addon.isCompatible) {
+        this.state = AddonManager.STATE_CHECKING;
+
+        yield new Promise(resolve => {
+          new UpdateChecker(this.addon, {
+            onUpdateFinished: aAddon => {
+              this.state = AddonManager.STATE_DOWNLOADED;
+              AddonManagerPrivate.callInstallListeners("onNewInstall",
+                                                       this.listeners,
+                                                       this.wrapper);
+              resolve();
+            }
+          }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
+        });
+      }
+      else {
+        AddonManagerPrivate.callInstallListeners("onNewInstall",
+                                                 this.listeners,
+                                                 this.wrapper);
+
+      }
+    }).bind(this));
+  }
+
+  install() {
+    if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) {
+      // For a local install, this state means that verification of the
+      // file failed (e.g., the hash or signature or manifest contents
+      // were invalid).  It doesn't make sense to retry anything in this
+      // case but we have callers who don't know if their AddonInstall
+      // object is a local file or a download so accomodate them here.
+      AddonManagerPrivate.callInstallListeners("onDownloadFailed",
+                                               this.listeners, this.wrapper);
+      return;
+    }
+    super.install();
+  }
+}
+
+class DownloadAddonInstall extends AddonInstall {
+  /**
+   * Instantiates a DownloadAddonInstall
+   *
+   * @param  installLocation
+   *         The InstallLocation the add-on will be installed into
+   * @param  url
+   *         The nsIURL to get the add-on from
+   * @param  name
+   *         An optional name for the add-on
+   * @param  hash
+   *         An optional hash for the add-on
+   * @param  existingAddon
+   *         The add-on this install will update if known
+   * @param  browser
+   *         The browser performing the install, used to display
+   *         authentication prompts.
+   * @param  type
+   *         An optional type for the add-on
+   * @param  icons
+   *         Optional icons for the add-on
+   * @param  version
+   *         An optional version for the add-on
+   */
+  constructor(installLocation, url, hash, existingAddon, browser,
+              name, type, icons, version) {
+    super(installLocation, url, hash, existingAddon);
+
+    this.browser = browser;
+
+    this.state = AddonManager.STATE_AVAILABLE;
+    this.name = name;
+    this.type = type;
+    this.version = version;
+    this.icons = icons;
+
+    this.stream = null;
+    this.crypto = null;
+    this.badCertHandler = null;
+    this.restartDownload = false;
+
+    AddonManagerPrivate.callInstallListeners("onNewInstall", this.listeners,
+                                            this.wrapper);
+  }
+
+  install() {
+    switch (this.state) {
+    case AddonManager.STATE_AVAILABLE:
+      this.startDownload();
+      break;
+    case AddonManager.STATE_DOWNLOAD_FAILED:
+    case AddonManager.STATE_INSTALL_FAILED:
+    case AddonManager.STATE_CANCELLED:
+      this.removeTemporaryFile();
+      this.state = AddonManager.STATE_AVAILABLE;
+      this.error = 0;
+      this.progress = 0;
+      this.maxProgress = -1;
+      this.hash = this.originalHash;
+      this.startDownload();
+      break;
+    default:
+      super.install();
+    }
+  }
+
+  cancel() {
+    if (this.state == AddonManager.STATE_DOWNLOADING) {
+      if (this.channel) {
+        logger.debug("Cancelling download of " + this.sourceURI.spec);
+        this.channel.cancel(Cr.NS_BINDING_ABORTED);
+      }
+    } else {
+      super.cancel();
+    }
+  }
+
+  observe(aSubject, aTopic, aData) {
+    // Network is going offline
+    this.cancel();
+  }
+
+  /**
+   * Starts downloading the add-on's XPI file.
+   */
+  startDownload() {
+    this.state = AddonManager.STATE_DOWNLOADING;
+    if (!AddonManagerPrivate.callInstallListeners("onDownloadStarted",
+                                                  this.listeners, this.wrapper)) {
+      logger.debug("onDownloadStarted listeners cancelled installation of addon " + this.sourceURI.spec);
+      this.state = AddonManager.STATE_CANCELLED;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
+                                               this.listeners, this.wrapper)
+      return;
+    }
+
+    // If a listener changed our state then do not proceed with the download
+    if (this.state != AddonManager.STATE_DOWNLOADING)
+      return;
+
+    if (this.channel) {
+      // A previous download attempt hasn't finished cleaning up yet, signal
+      // that it should restart when complete
+      logger.debug("Waiting for previous download to complete");
+      this.restartDownload = true;
+      return;
+    }
+
+    this.openChannel();
+  }
+
+  openChannel() {
+    this.restartDownload = false;
+
+    try {
+      this.file = getTemporaryFile();
+      this.ownsTempFile = true;
+      this.stream = Cc["@mozilla.org/network/file-output-stream;1"].
+                    createInstance(Ci.nsIFileOutputStream);
+      this.stream.init(this.file, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
+                       FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE, 0);
+    }
+    catch (e) {
+      logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
+      this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+      this.error = AddonManager.ERROR_FILE_ACCESS;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onDownloadFailed",
+                                               this.listeners, this.wrapper);
+      return;
+    }
+
+    let listener = Cc["@mozilla.org/network/stream-listener-tee;1"].
+                   createInstance(Ci.nsIStreamListenerTee);
+    listener.init(this, this.stream);
+    try {
+      let requireBuiltIn = Preferences.get(PREF_INSTALL_REQUIREBUILTINCERTS, true);
+      this.badCertHandler = new CertUtils.BadCertHandler(!requireBuiltIn);
+
+      this.channel = NetUtil.newChannel({
+        uri: this.sourceURI,
+        loadUsingSystemPrincipal: true
+      });
+      this.channel.notificationCallbacks = this;
+      if (this.channel instanceof Ci.nsIHttpChannel) {
+        this.channel.setRequestHeader("Moz-XPI-Update", "1", true);
+        if (this.channel instanceof Ci.nsIHttpChannelInternal)
+          this.channel.forceAllowThirdPartyCookie = true;
+      }
+      this.channel.asyncOpen2(listener);
+
+      Services.obs.addObserver(this, "network:offline-about-to-go-offline", false);
+    }
+    catch (e) {
+      logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
+      this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+      this.error = AddonManager.ERROR_NETWORK_FAILURE;
+      XPIProvider.removeActiveInstall(this);
+      AddonManagerPrivate.callInstallListeners("onDownloadFailed",
+                                               this.listeners, this.wrapper);
+    }
+  }
+
+  /**
+   * Update the crypto hasher with the new data and call the progress listeners.
+   *
+   * @see nsIStreamListener
+   */
+  onDataAvailable(aRequest, aContext, aInputstream, aOffset, aCount) {
+    this.crypto.updateFromStream(aInputstream, aCount);
+    this.progress += aCount;
+    if (!AddonManagerPrivate.callInstallListeners("onDownloadProgress",
+                                                  this.listeners, this.wrapper)) {
+      // TODO cancel the download and make it available again (bug 553024)
+    }
+  }
+
+  /**
+   * Check the redirect response for a hash of the target XPI and verify that
+   * we don't end up on an insecure channel.
+   *
+   * @see nsIChannelEventSink
+   */
+  asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback) {
+    if (!this.hash && aOldChannel.originalURI.schemeIs("https") &&
+        aOldChannel instanceof Ci.nsIHttpChannel) {
+      try {
+        let hashStr = aOldChannel.getResponseHeader("X-Target-Digest");
+        let hashSplit = hashStr.toLowerCase().split(":");
+        this.hash = {
+          algorithm: hashSplit[0],
+          data: hashSplit[1]
+        };
+      }
+      catch (e) {
+      }
+    }
+
+    // Verify that we don't end up on an insecure channel if we haven't got a
+    // hash to verify with (see bug 537761 for discussion)
+    if (!this.hash)
+      this.badCertHandler.asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback);
+    else
+      aCallback.onRedirectVerifyCallback(Cr.NS_OK);
+
+    this.channel = aNewChannel;
+  }
+
+  /**
+   * This is the first chance to get at real headers on the channel.
+   *
+   * @see nsIStreamListener
+   */
+  onStartRequest(aRequest, aContext) {
+    this.crypto = Cc["@mozilla.org/security/hash;1"].
+                  createInstance(Ci.nsICryptoHash);
+    if (this.hash) {
+      try {
+        this.crypto.initWithString(this.hash.algorithm);
+      }
+      catch (e) {
+        logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
+        this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+        this.error = AddonManager.ERROR_INCORRECT_HASH;
+        XPIProvider.removeActiveInstall(this);
+        AddonManagerPrivate.callInstallListeners("onDownloadFailed",
+                                                 this.listeners, this.wrapper);
+        aRequest.cancel(Cr.NS_BINDING_ABORTED);
+        return;
+      }
+    }
+    else {
+      // We always need something to consume data from the inputstream passed
+      // to onDataAvailable so just create a dummy cryptohasher to do that.
+      this.crypto.initWithString("sha1");
+    }
+
+    this.progress = 0;
+    if (aRequest instanceof Ci.nsIChannel) {
+      try {
+        this.maxProgress = aRequest.contentLength;
+      }
+      catch (e) {
+      }
+      logger.debug("Download started for " + this.sourceURI.spec + " to file " +
+          this.file.path);
+    }
+  }
+
+  /**
+   * The download is complete.
+   *
+   * @see nsIStreamListener
+   */
+  onStopRequest(aRequest, aContext, aStatus) {
+    this.stream.close();
+    this.channel = null;
+    this.badCerthandler = null;
+    Services.obs.removeObserver(this, "network:offline-about-to-go-offline");
+
+    // If the download was cancelled then update the state and send events
+    if (aStatus == Cr.NS_BINDING_ABORTED) {
+      if (this.state == AddonManager.STATE_DOWNLOADING) {
+        logger.debug("Cancelled download of " + this.sourceURI.spec);
+        this.state = AddonManager.STATE_CANCELLED;
+        XPIProvider.removeActiveInstall(this);
+        AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
+                                                 this.listeners, this.wrapper);
+        // If a listener restarted the download then there is no need to
+        // remove the temporary file
+        if (this.state != AddonManager.STATE_CANCELLED)
+          return;
+      }
+
+      this.removeTemporaryFile();
+      if (this.restartDownload)
+        this.openChannel();
+      return;
+    }
+
+    logger.debug("Download of " + this.sourceURI.spec + " completed.");
+
+    if (Components.isSuccessCode(aStatus)) {
+      if (!(aRequest instanceof Ci.nsIHttpChannel) || aRequest.requestSucceeded) {
+        if (!this.hash && (aRequest instanceof Ci.nsIChannel)) {
+          try {
+            CertUtils.checkCert(aRequest,
+                                !Preferences.get(PREF_INSTALL_REQUIREBUILTINCERTS, true));
+          }
+          catch (e) {
+            this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, e);
+            return;
+          }
+        }
+
+        // convert the binary hash data to a hex string.
+        let calculatedHash = getHashStringForCrypto(this.crypto);
+        this.crypto = null;
+        if (this.hash && calculatedHash != this.hash.data) {
+          this.downloadFailed(AddonManager.ERROR_INCORRECT_HASH,
+                              "Downloaded file hash (" + calculatedHash +
+                              ") did not match provided hash (" + this.hash.data + ")");
+          return;
+        }
+
+        this.loadManifest(this.file).then(() => {
+          if (this.addon.isCompatible) {
+            this.downloadCompleted();
+          }
+          else {
+            // TODO Should we send some event here (bug 557716)?
+            this.state = AddonManager.STATE_CHECKING;
+            new UpdateChecker(this.addon, {
+              onUpdateFinished: aAddon => this.downloadCompleted(),
+            }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
+          }
+        }, ([error, message]) => {
+          this.removeTemporaryFile();
+          this.downloadFailed(error, message);
+        });
+      }
+      else if (aRequest instanceof Ci.nsIHttpChannel) {
+        this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE,
+                            aRequest.responseStatus + " " +
+                            aRequest.responseStatusText);
+      }
+      else {
+        this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
+      }
+    }
+    else {
+      this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
+    }
+  }
+
+  /**
+   * Notify listeners that the download failed.
+   *
+   * @param  aReason
+   *         Something to log about the failure
+   * @param  error
+   *         The error code to pass to the listeners
+   */
+  downloadFailed(aReason, aError) {
+    logger.warn("Download of " + this.sourceURI.spec + " failed", aError);
+    this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+    this.error = aReason;
+    XPIProvider.removeActiveInstall(this);
+    AddonManagerPrivate.callInstallListeners("onDownloadFailed", this.listeners,
+                                             this.wrapper);
+
+    // If the listener hasn't restarted the download then remove any temporary
+    // file
+    if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) {
+      logger.debug("downloadFailed: removing temp file for " + this.sourceURI.spec);
+      this.removeTemporaryFile();
+    }
+    else
+      logger.debug("downloadFailed: listener changed AddonInstall state for " +
+          this.sourceURI.spec + " to " + this.state);
+  }
+
+  /**
+   * Notify listeners that the download completed.
+   */
+  downloadCompleted() {
+    XPIDatabase.getVisibleAddonForID(this.addon.id, aAddon => {
+      if (aAddon)
+        this.existingAddon = aAddon;
+
+      this.state = AddonManager.STATE_DOWNLOADED;
+      this.addon.updateDate = Date.now();
+
+      if (this.existingAddon) {
+        this.addon.existingAddonID = this.existingAddon.id;
+        this.addon.installDate = this.existingAddon.installDate;
+        applyBlocklistChanges(this.existingAddon, this.addon);
+      }
+      else {
+        this.addon.installDate = this.addon.updateDate;
+      }
+
+      if (AddonManagerPrivate.callInstallListeners("onDownloadEnded",
+                                                   this.listeners,
+                                                   this.wrapper)) {
+        // If a listener changed our state then do not proceed with the install
+        if (this.state != AddonManager.STATE_DOWNLOADED)
+          return;
+
+        // If an upgrade listener is registered for this add-on, pass control
+        // over the upgrade to the add-on.
+        if (AddonManagerPrivate.hasUpgradeListener(this.addon.id)) {
+          logger.info(`add-on ${this.addon.id} has an upgrade listener, postponing upgrade until restart`);
+          let resumeFn = () => {
+            logger.info(`${this.addon.id} has resumed a previously postponed upgrade`);
+            this.state = AddonManager.STATE_DOWNLOADED;
+            this.install();
+          }
+          this.postpone(resumeFn);
+        } else {
+          // no upgrade listener present, so proceed with normal install
+          this.install();
+          if (this.linkedInstalls) {
+            for (let install of this.linkedInstalls) {
+              if (install.state == AddonManager.STATE_DOWNLOADED)
+                install.install();
+            }
+          }
+        }
+      }
+    });
+  }
+
+  getInterface(iid) {
+    if (iid.equals(Ci.nsIAuthPrompt2)) {
+      let win = null;
+      if (this.browser) {
+        win = this.browser.contentWindow || this.browser.ownerDocument.defaultView;
+      }
+
+      let factory = Cc["@mozilla.org/prompter;1"].
+                    getService(Ci.nsIPromptFactory);
+      let prompt = factory.getPrompt(win, Ci.nsIAuthPrompt2);
+
+      if (this.browser && prompt instanceof Ci.nsILoginManagerPrompter)
+        prompt.browser = this.browser;
+
+      return prompt;
+    }
+    else if (iid.equals(Ci.nsIChannelEventSink)) {
+      return this;
+    }
+
+    return this.badCertHandler.getInterface(iid);
+  }
+
+  /**
+    * Postone a pending update, until restart or until the add-on resumes.
+    *
+    * @param {Function} resumeFn - a function for the add-on to run
+    *                                    when resuming.
+    */
+  postpone(resumeFn) {
+    return Task.spawn((function*() {
+      this.state = AddonManager.STATE_POSTPONED;
+
+      let stagingDir = this.installLocation.getStagingDir();
+      let stagedAddon = stagingDir.clone();
+
+      yield this.installLocation.requestStagingDir();
+      yield this.unstageInstall(stagedAddon);
+
+      stagedAddon.append(this.addon.id);
+      stagedAddon.leafName = this.addon.id + ".xpi";
+
+      yield this.stageInstall(true, stagedAddon, true);
+
+      AddonManagerPrivate.callInstallListeners("onInstallPostponed",
+                                               this.listeners, this.wrapper)
+
+      // upgrade has been staged for restart, provide a way for it to call the
+      // resume function.
+      let callback = AddonManagerPrivate.getUpgradeListener(this.addon.id);
+      if (callback) {
+        callback({
+          version: this.version,
+          install: () => {
+            switch (this.state) {
+            case AddonManager.STATE_POSTPONED:
+              if (resumeFn) {
+                resumeFn();
+              }
+              break;
+            default:
+              logger.warn(`${this.addon.id} cannot resume postponed upgrade from state (${this.state})`);
+              break;
+            }
+          },
+        });
+      }
+      // Release the staging directory lock, but since the staging dir is populated
+      // it will not be removed until resumed or installed by restart.
+      // See also cleanStagingDir()
+      this.installLocation.releaseStagingDir();
+    }).bind(this));
+  }
+}
+
+/**
+ * This class exists just for the specific case of staged add-ons that
+ * fail to install at startup.  When that happens, the add-on remains
+ * staged but we want to keep track of it like other installs so that we
+ * can clean it up if the same add-on is installed again (see the comment
+ * about "pending installs for the same add-on" in AddonInstall.startInstall)
+ */
+class StagedAddonInstall extends AddonInstall {
+  constructor(installLocation, dir, manifest) {
+    super(installLocation, dir);
+
+    this.name = manifest.name;
+    this.type = manifest.type;
+    this.version = manifest.version;
+    this.icons = manifest.icons;
+    this.releaseNotesURI = manifest.releaseNotesURI ?
+                           NetUtil.newURI(manifest.releaseNotesURI) :
+                           null;
+    this.sourceURI = manifest.sourceURI ?
+                     NetUtil.newURI(manifest.sourceURI) :
+                     null;
+    this.file = null;
+    this.addon = manifest;
+
+    this.state = AddonManager.STATE_INSTALLED;
+  }
+}
+
+/**
+ * Creates a new AddonInstall to install an add-on from a local file.
+ *
+ * @param  file
+ *         The file to install
+ * @param  location
+ *         The location to install to
+ * @returns Promise
+ *          A Promise that resolves with the new install object.
+ */
+function createLocalInstall(file, location) {
+  if (!location) {
+    location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
+  }
+  let url = Services.io.newFileURI(file);
+
+  try {
+    let install = new LocalAddonInstall(location, url);
+    return install.init().then(() => install);
+  }
+  catch (e) {
+    logger.error("Error creating install", e);
+    XPIProvider.removeActiveInstall(this);
+    return Promise.resolve(null);
+  }
+}
+
+/**
+ * Creates a new AddonInstall to download and install a URL.
+ *
+ * @param  aCallback
+ *         The callback to pass the new AddonInstall to
+ * @param  aUri
+ *         The URI to download
+ * @param  aHash
+ *         A hash for the add-on
+ * @param  aName
+ *         A name for the add-on
+ * @param  aIcons
+ *         An icon URLs for the add-on
+ * @param  aVersion
+ *         A version for the add-on
+ * @param  aBrowser
+ *         The browser performing the install
+ */
+function createDownloadInstall(aCallback, aUri, aHash, aName, aIcons,
+                               aVersion, aBrowser) {
+  let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
+  let url = NetUtil.newURI(aUri);
+
+  if (url instanceof Ci.nsIFileURL) {
+    let install = new LocalAddonInstall(location, url, aHash);
+    install.init().then(() => { aCallback(install); });
+  } else {
+    let install = new DownloadAddonInstall(location, url, aHash, null,
+                                           aBrowser, aName, null, aIcons,
+                                           aVersion);
+    aCallback(install);
+  }
+}
+
+/**
+ * Creates a new AddonInstall for an update.
+ *
+ * @param  aCallback
+ *         The callback to pass the new AddonInstall to
+ * @param  aAddon
+ *         The add-on being updated
+ * @param  aUpdate
+ *         The metadata about the new version from the update manifest
+ */
+function createUpdate(aCallback, aAddon, aUpdate) {
+  let url = NetUtil.newURI(aUpdate.updateURL);
+
+  Task.spawn(function*() {
+    let install;
+    if (url instanceof Ci.nsIFileURL) {
+      install = new LocalAddonInstall(aAddon._installLocation, url,
+                                      aUpdate.updateHash, aAddon);
+      yield install.init();
+    } else {
+      install = new DownloadAddonInstall(aAddon._installLocation, url,
+                                         aUpdate.updateHash, aAddon, null,
+                                         aAddon.selectedLocale.name, aAddon.type,
+                                         aAddon.icons, aUpdate.version);
+    }
+    try {
+      if (aUpdate.updateInfoURL)
+        install.releaseNotesURI = NetUtil.newURI(escapeAddonURI(aAddon, aUpdate.updateInfoURL));
+    }
+    catch (e) {
+      // If the releaseNotesURI cannot be parsed then just ignore it.
+    }
+
+    aCallback(install);
+  });
+}
+
+// This map is shared between AddonInstallWrapper and AddonWrapper
+const wrapperMap = new WeakMap();
+let installFor = wrapper => wrapperMap.get(wrapper);
+let addonFor = installFor;
+
+/**
+ * Creates a wrapper for an AddonInstall that only exposes the public API
+ *
+ * @param  install
+ *         The AddonInstall to create a wrapper for
+ */
+function AddonInstallWrapper(aInstall) {
+  wrapperMap.set(this, aInstall);
+}
+
+AddonInstallWrapper.prototype = {
+  get __AddonInstallInternal__() {
+    return AppConstants.DEBUG ? installFor(this) : undefined;
+  },
+
+  get type() {
+    return getExternalType(installFor(this).type);
+  },
+
+  get iconURL() {
+    return installFor(this).icons[32];
+  },
+
+  get existingAddon() {
+    let install = installFor(this);
+    return install.existingAddon ? install.existingAddon.wrapper : null;
+  },
+
+  get addon() {
+    let install = installFor(this);
+    return install.addon ? install.addon.wrapper : null;
+  },
+
+  get sourceURI() {
+    return installFor(this).sourceURI;
+  },
+
+  get linkedInstalls() {
+    let install = installFor(this);
+    if (!install.linkedInstalls)
+      return null;
+    return install.linkedInstalls.map(i => i.wrapper);
+  },
+
+  install: function() {
+    installFor(this).install();
+  },
+
+  cancel: function() {
+    installFor(this).cancel();
+  },
+
+  addListener: function(listener) {
+    installFor(this).addListener(listener);
+  },
+
+  removeListener: function(listener) {
+    installFor(this).removeListener(listener);
+  },
+};
+
+["name", "version", "icons", "releaseNotesURI", "file", "state", "error",
+ "progress", "maxProgress", "certificate", "certName"].forEach(function(aProp) {
+  Object.defineProperty(AddonInstallWrapper.prototype, aProp, {
+    get: function() {
+      return installFor(this)[aProp];
+    },
+    enumerable: true,
+  });
+});
+
+/**
+ * Creates a new update checker.
+ *
+ * @param  aAddon
+ *         The add-on to check for updates
+ * @param  aListener
+ *         An UpdateListener to notify of updates
+ * @param  aReason
+ *         The reason for the update check
+ * @param  aAppVersion
+ *         An optional application version to check for updates for
+ * @param  aPlatformVersion
+ *         An optional platform version to check for updates for
+ * @throws if the aListener or aReason arguments are not valid
+ */
+function UpdateChecker(aAddon, aListener, aReason, aAppVersion, aPlatformVersion) {
+  if (!aListener || !aReason)
+    throw Cr.NS_ERROR_INVALID_ARG;
+
+  Components.utils.import("resource://gre/modules/addons/AddonUpdateChecker.jsm");
+
+  this.addon = aAddon;
+  aAddon._updateCheck = this;
+  XPIProvider.doing(this);
+  this.listener = aListener;
+  this.appVersion = aAppVersion;
+  this.platformVersion = aPlatformVersion;
+  this.syncCompatibility = (aReason == AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
+
+  let updateURL = aAddon.updateURL;
+  if (!updateURL) {
+    if (aReason == AddonManager.UPDATE_WHEN_PERIODIC_UPDATE &&
+        Services.prefs.getPrefType(PREF_EM_UPDATE_BACKGROUND_URL) == Services.prefs.PREF_STRING) {
+      updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_BACKGROUND_URL);
+    } else {
+      updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_URL);
+    }
+  }
+
+  const UPDATE_TYPE_COMPATIBILITY = 32;
+  const UPDATE_TYPE_NEWVERSION = 64;
+
+  aReason |= UPDATE_TYPE_COMPATIBILITY;
+  if ("onUpdateAvailable" in this.listener)
+    aReason |= UPDATE_TYPE_NEWVERSION;
+
+  let url = escapeAddonURI(aAddon, updateURL, aReason, aAppVersion);
+  this._parser = AddonUpdateChecker.checkForUpdates(aAddon.id, aAddon.updateKey,
+                                                    url, this);
+}
+
+UpdateChecker.prototype = {
+  addon: null,
+  listener: null,
+  appVersion: null,
+  platformVersion: null,
+  syncCompatibility: null,
+
+  /**
+   * Calls a method on the listener passing any number of arguments and
+   * consuming any exceptions.
+   *
+   * @param  aMethod
+   *         The method to call on the listener
+   */
+  callListener: function(aMethod, ...aArgs) {
+    if (!(aMethod in this.listener))
+      return;
+
+    try {
+      this.listener[aMethod].apply(this.listener, aArgs);
+    }
+    catch (e) {
+      logger.warn("Exception calling UpdateListener method " + aMethod, e);
+    }
+  },
+
+  /**
+   * Called when AddonUpdateChecker completes the update check
+   *
+   * @param  updates
+   *         The list of update details for the add-on
+   */
+  onUpdateCheckComplete: function(aUpdates) {
+    XPIProvider.done(this.addon._updateCheck);
+    this.addon._updateCheck = null;
+    let AUC = AddonUpdateChecker;
+
+    let ignoreMaxVersion = false;
+    let ignoreStrictCompat = false;
+    if (!AddonManager.checkCompatibility) {
+      ignoreMaxVersion = true;
+      ignoreStrictCompat = true;
+    } else if (this.addon.type in COMPATIBLE_BY_DEFAULT_TYPES &&
+               !AddonManager.strictCompatibility &&
+               !this.addon.strictCompatibility &&
+               !this.addon.hasBinaryComponents) {
+      ignoreMaxVersion = true;
+    }
+
+    // Always apply any compatibility update for the current version
+    let compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
+                                                  this.syncCompatibility,
+                                                  null, null,
+                                                  ignoreMaxVersion,
+                                                  ignoreStrictCompat);
+    // Apply the compatibility update to the database
+    if (compatUpdate)
+      this.addon.applyCompatibilityUpdate(compatUpdate, this.syncCompatibility);
+
+    // If the request is for an application or platform version that is
+    // different to the current application or platform version then look for a
+    // compatibility update for those versions.
+    if ((this.appVersion &&
+         Services.vc.compare(this.appVersion, Services.appinfo.version) != 0) ||
+        (this.platformVersion &&
+         Services.vc.compare(this.platformVersion, Services.appinfo.platformVersion) != 0)) {
+      compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
+                                                false, this.appVersion,
+                                                this.platformVersion,
+                                                ignoreMaxVersion,
+                                                ignoreStrictCompat);
+    }
+
+    if (compatUpdate)
+      this.callListener("onCompatibilityUpdateAvailable", this.addon.wrapper);
+    else
+      this.callListener("onNoCompatibilityUpdateAvailable", this.addon.wrapper);
+
+    function sendUpdateAvailableMessages(aSelf, aInstall) {
+      if (aInstall) {
+        aSelf.callListener("onUpdateAvailable", aSelf.addon.wrapper,
+                           aInstall.wrapper);
+      }
+      else {
+        aSelf.callListener("onNoUpdateAvailable", aSelf.addon.wrapper);
+      }
+      aSelf.callListener("onUpdateFinished", aSelf.addon.wrapper,
+                         AddonManager.UPDATE_STATUS_NO_ERROR);
+    }
+
+    let compatOverrides = AddonManager.strictCompatibility ?
+                            null :
+                            this.addon.compatibilityOverrides;
+
+    let update = AUC.getNewestCompatibleUpdate(aUpdates,
+                                           this.appVersion,
+                                           this.platformVersion,
+                                           ignoreMaxVersion,
+                                           ignoreStrictCompat,
+                                           compatOverrides);
+
+    if (update && Services.vc.compare(this.addon.version, update.version) < 0
+        && !this.addon._installLocation.locked) {
+      for (let currentInstall of XPIProvider.installs) {
+        // Skip installs that don't match the available update
+        if (currentInstall.existingAddon != this.addon ||
+            currentInstall.version != update.version)
+          continue;
+
+        // If the existing install has not yet started downloading then send an
+        // available update notification. If it is already downloading then
+        // don't send any available update notification
+        if (currentInstall.state == AddonManager.STATE_AVAILABLE) {
+          logger.debug("Found an existing AddonInstall for " + this.addon.id);
+          sendUpdateAvailableMessages(this, currentInstall);
+        }
+        else
+          sendUpdateAvailableMessages(this, null);
+        return;
+      }
+
+      createUpdate(aInstall => {
+        sendUpdateAvailableMessages(this, aInstall);
+      }, this.addon, update);
+    }
+    else {
+      sendUpdateAvailableMessages(this, null);
+    }
+  },
+
+  /**
+   * Called when AddonUpdateChecker fails the update check
+   *
+   * @param  aError
+   *         An error status
+   */
+  onUpdateCheckError: function(aError) {
+    XPIProvider.done(this.addon._updateCheck);
+    this.addon._updateCheck = null;
+    this.callListener("onNoCompatibilityUpdateAvailable", this.addon.wrapper);
+    this.callListener("onNoUpdateAvailable", this.addon.wrapper);
+    this.callListener("onUpdateFinished", this.addon.wrapper, aError);
+  },
+
+  /**
+   * Called to cancel an in-progress update check
+   */
+  cancel: function() {
+    let parser = this._parser;
+    if (parser) {
+      this._parser = null;
+      // This will call back to onUpdateCheckError with a CANCELLED error
+      parser.cancel();
+    }
+  }
+};
+
+/**
+ * The AddonInternal is an internal only representation of add-ons. It may
+ * have come from the database (see DBAddonInternal in XPIProviderUtils.jsm)
+ * or an install manifest.
+ */
+function AddonInternal() {
+  this._hasResourceCache = new Map();
+
+  XPCOMUtils.defineLazyGetter(this, "wrapper", () => {
+    return new AddonWrapper(this);
+  });
+}
+
+AddonInternal.prototype = {
+  _selectedLocale: null,
+  _hasResourceCache: null,
+  active: false,
+  visible: false,
+  userDisabled: false,
+  appDisabled: false,
+  softDisabled: false,
+  sourceURI: null,
+  releaseNotesURI: null,
+  foreignInstall: false,
+  seen: true,
+  skinnable: false,
+
+  /**
+   * @property {Array<string>} dependencies
+   *   An array of bootstrapped add-on IDs on which this add-on depends.
+   *   The add-on will remain appDisabled if any of the dependent
+   *   add-ons is not installed and enabled.
+   */
+  dependencies: Object.freeze([]),
+  hasEmbeddedWebExtension: false,
+
+  get selectedLocale() {
+    if (this._selectedLocale)
+      return this._selectedLocale;
+    let locale = Locale.findClosestLocale(this.locales);
+    this._selectedLocale = locale ? locale : this.defaultLocale;
+    return this._selectedLocale;
+  },
+
+  get providesUpdatesSecurely() {
+    return !!(this.updateKey || !this.updateURL ||
+              this.updateURL.substring(0, 6) == "https:");
+  },
+
+  get isCorrectlySigned() {
+    switch (this._installLocation.name) {
+      case KEY_APP_SYSTEM_ADDONS:
+        // System add-ons must be signed by the system key.
+        return this.signedState == AddonManager.SIGNEDSTATE_SYSTEM
+
+      case KEY_APP_SYSTEM_DEFAULTS:
+      case KEY_APP_TEMPORARY:
+        // Temporary and built-in system add-ons do not require signing.
+        return true;
+
+      case KEY_APP_SYSTEM_SHARE:
+      case KEY_APP_SYSTEM_LOCAL:
+        // On UNIX platforms except OSX, an additional location for system
+        // add-ons exists in /usr/{lib,share}/mozilla/extensions. Add-ons
+        // installed there do not require signing.
+        if (Services.appinfo.OS != "Darwin")
+          return true;
+        break;
+    }
+
+    if (this.signedState === AddonManager.SIGNEDSTATE_NOT_REQUIRED)
+      return true;
+    return this.signedState > AddonManager.SIGNEDSTATE_MISSING;
+  },
+
+  get isCompatible() {
+    return this.isCompatibleWith();
+  },
+
+  get disabled() {
+    return (this.userDisabled || this.appDisabled || this.softDisabled);
+  },
+
+  get isPlatformCompatible() {
+    if (this.targetPlatforms.length == 0)
+      return true;
+
+    let matchedOS = false;
+
+    // If any targetPlatform matches the OS and contains an ABI then we will
+    // only match a targetPlatform that contains both the current OS and ABI
+    let needsABI = false;
+
+    // Some platforms do not specify an ABI, test against null in that case.
+    let abi = null;
+    try {
+      abi = Services.appinfo.XPCOMABI;
+    }
+    catch (e) { }
+
+    // Something is causing errors in here
+    try {
+      for (let platform of this.targetPlatforms) {
+        if (platform.os == Services.appinfo.OS) {
+          if (platform.abi) {
+            needsABI = true;
+            if (platform.abi === abi)
+              return true;
+          }
+          else {
+            matchedOS = true;
+          }
+        }
+      }
+    } catch (e) {
+      let message = "Problem with addon " + this.id + " targetPlatforms "
+                    + JSON.stringify(this.targetPlatforms);
+      logger.error(message, e);
+      AddonManagerPrivate.recordException("XPI", message, e);
+      // don't trust this add-on
+      return false;
+    }
+
+    return matchedOS && !needsABI;
+  },
+
+  isCompatibleWith: function(aAppVersion, aPlatformVersion) {
+    let app = this.matchingTargetApplication;
+    if (!app)
+      return false;
+
+    // set reasonable defaults for minVersion and maxVersion
+    let minVersion = app.minVersion || "0";
+    let maxVersion = app.maxVersion || "*";
+
+    if (!aAppVersion)
+      aAppVersion = Services.appinfo.version;
+    if (!aPlatformVersion)
+      aPlatformVersion = Services.appinfo.platformVersion;
+
+    let version;
+    if (app.id == Services.appinfo.ID)
+      version = aAppVersion;
+    else if (app.id == TOOLKIT_ID)
+      version = aPlatformVersion
+
+    // Only extensions and dictionaries can be compatible by default; themes
+    // and language packs always use strict compatibility checking.
+    if (this.type in COMPATIBLE_BY_DEFAULT_TYPES &&
+        !AddonManager.strictCompatibility && !this.strictCompatibility &&
+        !this.hasBinaryComponents) {
+
+      // The repository can specify compatibility overrides.
+      // Note: For now, only blacklisting is supported by overrides.
+      if (this._repositoryAddon &&
+          this._repositoryAddon.compatibilityOverrides) {
+        let overrides = this._repositoryAddon.compatibilityOverrides;
+        let override = AddonRepository.findMatchingCompatOverride(this.version,
+                                                                  overrides);
+        if (override && override.type == "incompatible")
+          return false;
+      }
+
+      // Extremely old extensions should not be compatible by default.
+      let minCompatVersion;
+      if (app.id == Services.appinfo.ID)
+        minCompatVersion = XPIProvider.minCompatibleAppVersion;
+      else if (app.id == TOOLKIT_ID)
+        minCompatVersion = XPIProvider.minCompatiblePlatformVersion;
+
+      if (minCompatVersion &&
+          Services.vc.compare(minCompatVersion, maxVersion) > 0)
+        return false;
+
+      return Services.vc.compare(version, minVersion) >= 0;
+    }
+
+    return (Services.vc.compare(version, minVersion) >= 0) &&
+           (Services.vc.compare(version, maxVersion) <= 0)
+  },
+
+  get matchingTargetApplication() {
+    let app = null;
+    for (let targetApp of this.targetApplications) {
+      if (targetApp.id == Services.appinfo.ID)
+        return targetApp;
+      if (targetApp.id == TOOLKIT_ID)
+        app = targetApp;
+    }
+    return app;
+  },
+
+  get blocklistState() {
+    let staticItem = findMatchingStaticBlocklistItem(this);
+    if (staticItem)
+      return staticItem.level;
+
+    return Blocklist.getAddonBlocklistState(this.wrapper);
+  },
+
+  get blocklistURL() {
+    let staticItem = findMatchingStaticBlocklistItem(this);
+    if (staticItem) {
+      let url = Services.urlFormatter.formatURLPref("extensions.blocklist.itemURL");
+      return url.replace(/%blockID%/g, staticItem.blockID);
+    }
+
+    return Blocklist.getAddonBlocklistURL(this.wrapper);
+  },
+
+  applyCompatibilityUpdate: function(aUpdate, aSyncCompatibility) {
+    for (let targetApp of this.targetApplications) {
+      for (let updateTarget of aUpdate.targetApplications) {
+        if (targetApp.id == updateTarget.id && (aSyncCompatibility ||
+            Services.vc.compare(targetApp.maxVersion, updateTarget.maxVersion) < 0)) {
+          targetApp.minVersion = updateTarget.minVersion;
+          targetApp.maxVersion = updateTarget.maxVersion;
+        }
+      }
+    }
+    if (aUpdate.multiprocessCompatible !== undefined)
+      this.multiprocessCompatible = aUpdate.multiprocessCompatible;
+    this.appDisabled = !isUsableAddon(this);
+  },
+
+  /**
+   * getDataDirectory tries to execute the callback with two arguments:
+   * 1) the path of the data directory within the profile,
+   * 2) any exception generated from trying to build it.
+   */
+  getDataDirectory: function(callback) {
+    let parentPath = OS.Path.join(OS.Constants.Path.profileDir, "extension-data");
+    let dirPath = OS.Path.join(parentPath, this.id);
+
+    Task.spawn(function*() {
+      yield OS.File.makeDir(parentPath, {ignoreExisting: true});
+      yield OS.File.makeDir(dirPath, {ignoreExisting: true});
+    }).then(() => callback(dirPath, null),
+            e => callback(dirPath, e));
+  },
+
+  /**
+   * toJSON is called by JSON.stringify in order to create a filtered version
+   * of this object to be serialized to a JSON file. A new object is returned
+   * with copies of all non-private properties. Functions, getters and setters
+   * are not copied.
+   *
+   * @param  aKey
+   *         The key that this object is being serialized as in the JSON.
+   *         Unused here since this is always the main object serialized
+   *
+   * @return an object containing copies of the properties of this object
+   *         ignoring private properties, functions, getters and setters
+   */
+  toJSON: function(aKey) {
+    let obj = {};
+    for (let prop in this) {
+      // Ignore the wrapper property
+      if (prop == "wrapper")
+        continue;
+
+      // Ignore private properties
+      if (prop.substring(0, 1) == "_")
+        continue;
+
+      // Ignore getters
+      if (this.__lookupGetter__(prop))
+        continue;
+
+      // Ignore setters
+      if (this.__lookupSetter__(prop))
+        continue;
+
+      // Ignore functions
+      if (typeof this[prop] == "function")
+        continue;
+
+      obj[prop] = this[prop];
+    }
+
+    return obj;
+  },
+
+  /**
+   * When an add-on install is pending its metadata will be cached in a file.
+   * This method reads particular properties of that metadata that may be newer
+   * than that in the install manifest, like compatibility information.
+   *
+   * @param  aObj
+   *         A JS object containing the cached metadata
+   */
+  importMetadata: function(aObj) {
+    for (let prop of PENDING_INSTALL_METADATA) {
+      if (!(prop in aObj))
+        continue;
+
+      this[prop] = aObj[prop];
+    }
+
+    // Compatibility info may have changed so update appDisabled
+    this.appDisabled = !isUsableAddon(this);
+  },
+
+  permissions: function() {
+    let permissions = 0;
+
+    // Add-ons that aren't installed cannot be modified in any way
+    if (!(this.inDatabase))
+      return permissions;
+
+    if (!this.appDisabled) {
+      if (this.userDisabled || this.softDisabled) {
+        permissions |= AddonManager.PERM_CAN_ENABLE;
+      }
+      else if (this.type != "theme") {
+        permissions |= AddonManager.PERM_CAN_DISABLE;
+      }
+    }
+
+    // Add-ons that are in locked install locations, or are pending uninstall
+    // cannot be upgraded or uninstalled
+    if (!this._installLocation.locked && !this.pendingUninstall) {
+      // Experiments cannot be upgraded.
+      // System add-on upgrades are triggered through a different mechanism (see updateSystemAddons())
+      let isSystem = (this._installLocation.name == KEY_APP_SYSTEM_DEFAULTS ||
+                      this._installLocation.name == KEY_APP_SYSTEM_ADDONS);
+      // Add-ons that are installed by a file link cannot be upgraded.
+      if (this.type != "experiment" &&
+          !this._installLocation.isLinkedAddon(this.id) && !isSystem) {
+        permissions |= AddonManager.PERM_CAN_UPGRADE;
+      }
+
+      permissions |= AddonManager.PERM_CAN_UNINSTALL;
+    }
+
+    return permissions;
+  },
+};
+
+/**
+ * The AddonWrapper wraps an Addon to provide the data visible to consumers of
+ * the public API.
+ */
+function AddonWrapper(aAddon) {
+  wrapperMap.set(this, aAddon);
+}
+
+AddonWrapper.prototype = {
+  get __AddonInternal__() {
+    return AppConstants.DEBUG ? addonFor(this) : undefined;
+  },
+
+  get seen() {
+    return addonFor(this).seen;
+  },
+
+  get hasEmbeddedWebExtension() {
+    return addonFor(this).hasEmbeddedWebExtension;
+  },
+
+  markAsSeen: function() {
+    addonFor(this).seen = true;
+    XPIDatabase.saveChanges();
+  },
+
+  get type() {
+    return getExternalType(addonFor(this).type);
+  },
+
+  get isWebExtension() {
+    return addonFor(this).type == "webextension";
+  },
+
+  get temporarilyInstalled() {
+    return addonFor(this)._installLocation == TemporaryInstallLocation;
+  },
+
+  get aboutURL() {
+    return this.isActive ? addonFor(this)["aboutURL"] : null;
+  },
+
+  get optionsURL() {
+    if (!this.isActive) {
+      return null;
+    }
+
+    let addon = addonFor(this);
+    if (addon.optionsURL) {
+      if (this.isWebExtension || this.hasEmbeddedWebExtension) {
+        // The internal object's optionsURL property comes from the addons
+        // DB and should be a relative URL.  However, extensions with
+        // options pages installed before bug 1293721 was fixed got absolute
+        // URLs in the addons db.  This code handles both cases.
+        let base = ExtensionManagement.getURLForExtension(addon.id);
+        if (!base) {
+          return null;
+        }
+        return new URL(addon.optionsURL, base).href;
+      }
+      return addon.optionsURL;
+    }
+
+    if (this.hasResource("options.xul"))
+      return this.getResourceURI("options.xul").spec;
+
+    return null;
+  },
+
+  get optionsType() {
+    if (!this.isActive)
+      return null;
+
+    let addon = addonFor(this);
+    let hasOptionsXUL = this.hasResource("options.xul");
+    let hasOptionsURL = !!this.optionsURL;
+
+    if (addon.optionsType) {
+      switch (parseInt(addon.optionsType, 10)) {
+      case AddonManager.OPTIONS_TYPE_DIALOG:
+      case AddonManager.OPTIONS_TYPE_TAB:
+        return hasOptionsURL ? addon.optionsType : null;
+      case AddonManager.OPTIONS_TYPE_INLINE:
+      case AddonManager.OPTIONS_TYPE_INLINE_INFO:
+      case AddonManager.OPTIONS_TYPE_INLINE_BROWSER:
+        return (hasOptionsXUL || hasOptionsURL) ? addon.optionsType : null;
+      }
+      return null;
+    }
+
+    if (hasOptionsXUL)
+      return AddonManager.OPTIONS_TYPE_INLINE;
+
+    if (hasOptionsURL)
+      return AddonManager.OPTIONS_TYPE_DIALOG;
+
+    return null;
+  },
+
+  get iconURL() {
+    return AddonManager.getPreferredIconURL(this, 48);
+  },
+
+  get icon64URL() {
+    return AddonManager.getPreferredIconURL(this, 64);
+  },
+
+  get icons() {
+    let addon = addonFor(this);
+    let icons = {};
+
+    if (addon._repositoryAddon) {
+      for (let size in addon._repositoryAddon.icons) {
+        icons[size] = addon._repositoryAddon.icons[size];
+      }
+    }
+
+    if (addon.icons) {
+      for (let size in addon.icons) {
+        icons[size] = this.getResourceURI(addon.icons[size]).spec;
+      }
+    } else {
+      // legacy add-on that did not update its icon data yet
+      if (this.hasResource("icon.png")) {
+        icons[32] = icons[48] = this.getResourceURI("icon.png").spec;
+      }
+      if (this.hasResource("icon64.png")) {
+        icons[64] = this.getResourceURI("icon64.png").spec;
+      }
+    }
+
+    if (this.isActive && addon.iconURL) {
+      icons[32] = addon.iconURL;
+      icons[48] = addon.iconURL;
+    }
+
+    if (this.isActive && addon.icon64URL) {
+      icons[64] = addon.icon64URL;
+    }
+
+    Object.freeze(icons);
+    return icons;
+  },
+
+  get screenshots() {
+    let addon = addonFor(this);
+    let repositoryAddon = addon._repositoryAddon;
+    if (repositoryAddon && ("screenshots" in repositoryAddon)) {
+      let repositoryScreenshots = repositoryAddon.screenshots;
+      if (repositoryScreenshots && repositoryScreenshots.length > 0)
+        return repositoryScreenshots;
+    }
+
+    if (addon.type == "theme" && this.hasResource("preview.png")) {
+      let url = this.getResourceURI("preview.png").spec;
+      return [new AddonManagerPrivate.AddonScreenshot(url)];
+    }
+
+    return null;
+  },
+
+  get applyBackgroundUpdates() {
+    return addonFor(this).applyBackgroundUpdates;
+  },
+  set applyBackgroundUpdates(val) {
+    let addon = addonFor(this);
+    if (this.type == "experiment") {
+      logger.warn("Setting applyBackgroundUpdates on an experiment is not supported.");
+      return addon.applyBackgroundUpdates;
+    }
+
+    if (val != AddonManager.AUTOUPDATE_DEFAULT &&
+        val != AddonManager.AUTOUPDATE_DISABLE &&
+        val != AddonManager.AUTOUPDATE_ENABLE) {
+      val = val ? AddonManager.AUTOUPDATE_DEFAULT :
+                  AddonManager.AUTOUPDATE_DISABLE;
+    }
+
+    if (val == addon.applyBackgroundUpdates)
+      return val;
+
+    XPIDatabase.setAddonProperties(addon, {
+      applyBackgroundUpdates: val
+    });
+    AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["applyBackgroundUpdates"]);
+
+    return val;
+  },
+
+  set syncGUID(val) {
+    let addon = addonFor(this);
+    if (addon.syncGUID == val)
+      return val;
+
+    if (addon.inDatabase)
+      XPIDatabase.setAddonSyncGUID(addon, val);
+
+    addon.syncGUID = val;
+
+    return val;
+  },
+
+  get install() {
+    let addon = addonFor(this);
+    if (!("_install" in addon) || !addon._install)
+      return null;
+    return addon._install.wrapper;
+  },
+
+  get pendingUpgrade() {
+    let addon = addonFor(this);
+    return addon.pendingUpgrade ? addon.pendingUpgrade.wrapper : null;
+  },
+
+  get scope() {
+    let addon = addonFor(this);
+    if (addon._installLocation)
+      return addon._installLocation.scope;
+
+    return AddonManager.SCOPE_PROFILE;
+  },
+
+  get pendingOperations() {
+    let addon = addonFor(this);
+    let pending = 0;
+    if (!(addon.inDatabase)) {
+      // Add-on is pending install if there is no associated install (shouldn't
+      // happen here) or if the install is in the process of or has successfully
+      // completed the install. If an add-on is pending install then we ignore
+      // any other pending operations.
+      if (!addon._install || addon._install.state == AddonManager.STATE_INSTALLING ||
+          addon._install.state == AddonManager.STATE_INSTALLED)
+        return AddonManager.PENDING_INSTALL;
+    }
+    else if (addon.pendingUninstall) {
+      // If an add-on is pending uninstall then we ignore any other pending
+      // operations
+      return AddonManager.PENDING_UNINSTALL;
+    }
+
+    if (addon.active && addon.disabled)
+      pending |= AddonManager.PENDING_DISABLE;
+    else if (!addon.active && !addon.disabled)
+      pending |= AddonManager.PENDING_ENABLE;
+
+    if (addon.pendingUpgrade)
+      pending |= AddonManager.PENDING_UPGRADE;
+
+    return pending;
+  },
+
+  get operationsRequiringRestart() {
+    let addon = addonFor(this);
+    let ops = 0;
+    if (XPIProvider.installRequiresRestart(addon))
+      ops |= AddonManager.OP_NEEDS_RESTART_INSTALL;
+    if (XPIProvider.uninstallRequiresRestart(addon))
+      ops |= AddonManager.OP_NEEDS_RESTART_UNINSTALL;
+    if (XPIProvider.enableRequiresRestart(addon))
+      ops |= AddonManager.OP_NEEDS_RESTART_ENABLE;
+    if (XPIProvider.disableRequiresRestart(addon))
+      ops |= AddonManager.OP_NEEDS_RESTART_DISABLE;
+
+    return ops;
+  },
+
+  get isDebuggable() {
+    return this.isActive && addonFor(this).bootstrap;
+  },
+
+  get permissions() {
+    return addonFor(this).permissions();
+  },
+
+  get isActive() {
+    let addon = addonFor(this);
+    if (!addon.active)
+      return false;
+    if (!Services.appinfo.inSafeMode)
+      return true;
+    return addon.bootstrap && canRunInSafeMode(addon);
+  },
+
+  get userDisabled() {
+    let addon = addonFor(this);
+    return addon.softDisabled || addon.userDisabled;
+  },
+  set userDisabled(val) {
+    let addon = addonFor(this);
+    if (val == this.userDisabled) {
+      return val;
+    }
+
+    if (addon.inDatabase) {
+      if (addon.type == "theme" && val) {
+        if (addon.internalName == XPIProvider.defaultSkin)
+          throw new Error("Cannot disable the default theme");
+        XPIProvider.enableDefaultTheme();
+      }
+      else {
+        // hidden and system add-ons should not be user disasbled,
+        // as there is no UI to re-enable them.
+        if (this.hidden) {
+          throw new Error(`Cannot disable hidden add-on ${addon.id}`);
+        }
+        XPIProvider.updateAddonDisabledState(addon, val);
+      }
+    }
+    else {
+      addon.userDisabled = val;
+      // When enabling remove the softDisabled flag
+      if (!val)
+        addon.softDisabled = false;
+    }
+
+    return val;
+  },
+
+  set softDisabled(val) {
+    let addon = addonFor(this);
+    if (val == addon.softDisabled)
+      return val;
+
+    if (addon.inDatabase) {
+      // When softDisabling a theme just enable the active theme
+      if (addon.type == "theme" && val && !addon.userDisabled) {
+        if (addon.internalName == XPIProvider.defaultSkin)
+          throw new Error("Cannot disable the default theme");
+        XPIProvider.enableDefaultTheme();
+      }
+      else {
+        XPIProvider.updateAddonDisabledState(addon, undefined, val);
+      }
+    }
+    else if (!addon.userDisabled) {
+      // Only set softDisabled if not already disabled
+      addon.softDisabled = val;
+    }
+
+    return val;
+  },
+
+  get hidden() {
+    let addon = addonFor(this);
+    if (addon._installLocation.name == KEY_APP_TEMPORARY)
+      return false;
+
+    return (addon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS ||
+            addon._installLocation.name == KEY_APP_SYSTEM_ADDONS);
+  },
+
+  get isSystem() {
+    let addon = addonFor(this);
+    return (addon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS ||
+            addon._installLocation.name == KEY_APP_SYSTEM_ADDONS);
+  },
+
+  // Returns true if Firefox Sync should sync this addon. Only non-hotfixes
+  // directly in the profile are considered syncable.
+  get isSyncable() {
+    let addon = addonFor(this);
+    let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined);
+    if (hotfixID && hotfixID == addon.id) {
+      return false;
+    }
+    return (addon._installLocation.name == KEY_APP_PROFILE);
+  },
+
+  isCompatibleWith: function(aAppVersion, aPlatformVersion) {
+    return addonFor(this).isCompatibleWith(aAppVersion, aPlatformVersion);
+  },
+
+  uninstall: function(alwaysAllowUndo) {
+    let addon = addonFor(this);
+    XPIProvider.uninstallAddon(addon, alwaysAllowUndo);
+  },
+
+  cancelUninstall: function() {
+    let addon = addonFor(this);
+    XPIProvider.cancelUninstallAddon(addon);
+  },
+
+  findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) {
+    // Short-circuit updates for experiments because updates are handled
+    // through the Experiments Manager.
+    if (this.type == "experiment") {
+      AddonManagerPrivate.callNoUpdateListeners(this, aListener, aReason,
+                                                aAppVersion, aPlatformVersion);
+      return;
+    }
+
+    new UpdateChecker(addonFor(this), aListener, aReason, aAppVersion, aPlatformVersion);
+  },
+
+  // Returns true if there was an update in progress, false if there was no update to cancel
+  cancelUpdate: function() {
+    let addon = addonFor(this);
+    if (addon._updateCheck) {
+      addon._updateCheck.cancel();
+      return true;
+    }
+    return false;
+  },
+
+  hasResource: function(aPath) {
+    let addon = addonFor(this);
+    if (addon._hasResourceCache.has(aPath))
+      return addon._hasResourceCache.get(aPath);
+
+    let bundle = addon._sourceBundle.clone();
+
+    // Bundle may not exist any more if the addon has just been uninstalled,
+    // but explicitly first checking .exists() results in unneeded file I/O.
+    try {
+      var isDir = bundle.isDirectory();
+    } catch (e) {
+      addon._hasResourceCache.set(aPath, false);
+      return false;
+    }
+
+    if (isDir) {
+      if (aPath)
+        aPath.split("/").forEach(part => bundle.append(part));
+      let result = bundle.exists();
+      addon._hasResourceCache.set(aPath, result);
+      return result;
+    }
+
+    let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
+                    createInstance(Ci.nsIZipReader);
+    try {
+      zipReader.open(bundle);
+      let result = zipReader.hasEntry(aPath);
+      addon._hasResourceCache.set(aPath, result);
+      return result;
+    }
+    catch (e) {
+      addon._hasResourceCache.set(aPath, false);
+      return false;
+    }
+    finally {
+      zipReader.close();
+    }
+  },
+
+  /**
+   * Reloads the add-on.
+   *
+   * For temporarily installed add-ons, this uninstalls and re-installs the
+   * add-on. Otherwise, the addon is disabled and then re-enabled, and the cache
+   * is flushed.
+   *
+   * @return Promise
+   */
+  reload: function() {
+    return new Promise((resolve) => {
+      const addon = addonFor(this);
+
+      logger.debug(`reloading add-on ${addon.id}`);
+
+      if (!this.temporarilyInstalled) {
+        let addonFile = addon.getResourceURI;
+        XPIProvider.updateAddonDisabledState(addon, true);
+        Services.obs.notifyObservers(addonFile, "flush-cache-entry", null);
+        XPIProvider.updateAddonDisabledState(addon, false)
+        resolve();
+      } else {
+        // This function supports re-installing an existing add-on.
+        resolve(AddonManager.installTemporaryAddon(addon._sourceBundle));
+      }
+    });
+  },
+
+  /**
+   * Returns a URI to the selected resource or to the add-on bundle if aPath
+   * is null. URIs to the bundle will always be file: URIs. URIs to resources
+   * will be file: URIs if the add-on is unpacked or jar: URIs if the add-on is
+   * still an XPI file.
+   *
+   * @param  aPath
+   *         The path in the add-on to get the URI for or null to get a URI to
+   *         the file or directory the add-on is installed as.
+   * @return an nsIURI
+   */
+  getResourceURI: function(aPath) {
+    let addon = addonFor(this);
+    if (!aPath)
+      return NetUtil.newURI(addon._sourceBundle);
+
+    return getURIForResourceInFile(addon._sourceBundle, aPath);
+  }
+};
+
+/**
+ * The PrivateWrapper is used to expose certain functionality only when being
+ * called with the add-on instanceID, disallowing other add-ons to access it.
+ */
+function PrivateWrapper(aAddon) {
+  AddonWrapper.call(this, aAddon);
+}
+
+PrivateWrapper.prototype = Object.create(AddonWrapper.prototype);
+Object.assign(PrivateWrapper.prototype, {
+  addonId() {
+    return this.id;
+  },
+
+  /**
+   * Retrieves the preferred global context to be used from the
+   * add-on debugging window.
+   *
+   * @returns  global
+   *         The object set as global context. Must be a window object.
+   */
+  getDebugGlobal(global) {
+    let activeAddon = XPIProvider.activeAddons.get(this.id);
+    if (activeAddon) {
+      return activeAddon.debugGlobal;
+    }
+
+    return null;
+  },
+
+  /**
+   * Defines a global context to be used in the console
+   * of the add-on debugging window.
+   *
+   * @param  global
+   *         The object to set as global context. Must be a window object.
+   */
+  setDebugGlobal(global) {
+    if (!global) {
+      // If the new global is null, notify the listeners regardless
+      // from the current state of the addon.
+      // NOTE: this happen after the addon has been disabled and
+      // the global will never be set to null otherwise.
+      AddonManagerPrivate.callAddonListeners("onPropertyChanged",
+                                             addonFor(this),
+                                             ["debugGlobal"]);
+    } else {
+      let activeAddon = XPIProvider.activeAddons.get(this.id);
+      if (activeAddon) {
+        let globalChanged = activeAddon.debugGlobal != global;
+        activeAddon.debugGlobal = global;
+
+        if (globalChanged) {
+          AddonManagerPrivate.callAddonListeners("onPropertyChanged",
+                                                 addonFor(this),
+                                                 ["debugGlobal"]);
+        }
+      }
+    }
+  }
+});
+
+function chooseValue(aAddon, aObj, aProp) {
+  let repositoryAddon = aAddon._repositoryAddon;
+  let objValue = aObj[aProp];
+
+  if (repositoryAddon && (aProp in repositoryAddon) &&
+      (objValue === undefined || objValue === null)) {
+    return [repositoryAddon[aProp], true];
+  }
+
+  return [objValue, false];
+}
+
+function defineAddonWrapperProperty(name, getter) {
+  Object.defineProperty(AddonWrapper.prototype, name, {
+    get: getter,
+    enumerable: true,
+  });
+}
+
+["id", "syncGUID", "version", "isCompatible", "isPlatformCompatible",
+ "providesUpdatesSecurely", "blocklistState", "blocklistURL", "appDisabled",
+ "softDisabled", "skinnable", "size", "foreignInstall", "hasBinaryComponents",
+ "strictCompatibility", "compatibilityOverrides", "updateURL", "dependencies",
+ "getDataDirectory", "multiprocessCompatible", "signedState", "mpcOptedOut",
+ "isCorrectlySigned"].forEach(function(aProp) {
+   defineAddonWrapperProperty(aProp, function() {
+     let addon = addonFor(this);
+     return (aProp in addon) ? addon[aProp] : undefined;
+   });
+});
+
+["fullDescription", "developerComments", "eula", "supportURL",
+ "contributionURL", "contributionAmount", "averageRating", "reviewCount",
+ "reviewURL", "totalDownloads", "weeklyDownloads", "dailyUsers",
+ "repositoryStatus"].forEach(function(aProp) {
+  defineAddonWrapperProperty(aProp, function() {
+    let addon = addonFor(this);
+    if (addon._repositoryAddon)
+      return addon._repositoryAddon[aProp];
+
+    return null;
+  });
+});
+
+["installDate", "updateDate"].forEach(function(aProp) {
+  defineAddonWrapperProperty(aProp, function() {
+    return new Date(addonFor(this)[aProp]);
+  });
+});
+
+["sourceURI", "releaseNotesURI"].forEach(function(aProp) {
+  defineAddonWrapperProperty(aProp, function() {
+    let addon = addonFor(this);
+
+    // Temporary Installed Addons do not have a "sourceURI",
+    // But we can use the "_sourceBundle" as an alternative,
+    // which points to the path of the addon xpi installed
+    // or its source dir (if it has been installed from a
+    // directory).
+    if (aProp == "sourceURI" && this.temporarilyInstalled) {
+      return Services.io.newFileURI(addon._sourceBundle);
+    }
+
+    let [target, fromRepo] = chooseValue(addon, addon, aProp);
+    if (!target)
+      return null;
+    if (fromRepo)
+      return target;
+    return NetUtil.newURI(target);
+  });
+});
+
+PROP_LOCALE_SINGLE.forEach(function(aProp) {
+  defineAddonWrapperProperty(aProp, function() {
+    let addon = addonFor(this);
+    // Override XPI creator if repository creator is defined
+    if (aProp == "creator" &&
+        addon._repositoryAddon && addon._repositoryAddon.creator) {
+      return addon._repositoryAddon.creator;
+    }
+
+    let result = null;
+
+    if (addon.active) {
+      try {
+        let pref = PREF_EM_EXTENSION_FORMAT + addon.id + "." + aProp;
+        let value = Preferences.get(pref, null, Ci.nsIPrefLocalizedString);
+        if (value)
+          result = value;
+      }
+      catch (e) {
+      }
+    }
+
+    let rest;
+    if (result == null)
+      [result, ...rest] = chooseValue(addon, addon.selectedLocale, aProp);
+
+    if (aProp == "creator")
+      return result ? new AddonManagerPrivate.AddonAuthor(result) : null;
+
+    return result;
+  });
+});
+
+PROP_LOCALE_MULTI.forEach(function(aProp) {
+  defineAddonWrapperProperty(aProp, function() {
+    let addon = addonFor(this);
+    let results = null;
+    let usedRepository = false;
+
+    if (addon.active) {
+      let pref = PREF_EM_EXTENSION_FORMAT + addon.id + "." +
+                 aProp.substring(0, aProp.length - 1);
+      let list = Services.prefs.getChildList(pref, {});
+      if (list.length > 0) {
+        list.sort();
+        results = [];
+        for (let childPref of list) {
+          let value = Preferences.get(childPref, null, Ci.nsIPrefLocalizedString);
+          if (value)
+            results.push(value);
+        }
+      }
+    }
+
+    if (results == null)
+      [results, usedRepository] = chooseValue(addon, addon.selectedLocale, aProp);
+
+    if (results && !usedRepository) {
+      results = results.map(function(aResult) {
+        return new AddonManagerPrivate.AddonAuthor(aResult);
+      });
+    }
+
+    return results;
+  });
+});
+
+/**
+ * An object which identifies a directory install location for add-ons. The
+ * location consists of a directory which contains the add-ons installed in the
+ * location.
+ *
+ * Each add-on installed in the location is either a directory containing the
+ * add-on's files or a text file containing an absolute path to the directory
+ * containing the add-ons files. The directory or text file must have the same
+ * name as the add-on's ID.
+ *
+ * @param  aName
+ *         The string identifier for the install location
+ * @param  aDirectory
+ *         The nsIFile directory for the install location
+ * @param  aScope
+ *         The scope of add-ons installed in this location
+ */
+function DirectoryInstallLocation(aName, aDirectory, aScope) {
+  this._name = aName;
+  this.locked = true;
+  this._directory = aDirectory;
+  this._scope = aScope
+  this._IDToFileMap = {};
+  this._linkedAddons = [];
+
+  if (!aDirectory || !aDirectory.exists())
+    return;
+  if (!aDirectory.isDirectory())
+    throw new Error("Location must be a directory.");
+
+  this._readAddons();
+}
+
+DirectoryInstallLocation.prototype = {
+  _name       : "",
+  _directory   : null,
+  _IDToFileMap : null,  // mapping from add-on ID to nsIFile
+
+  /**
+   * Reads a directory linked to in a file.
+   *
+   * @param   file
+   *          The file containing the directory path
+   * @return  An nsIFile object representing the linked directory.
+   */
+  _readDirectoryFromFile: function(aFile) {
+    let linkedDirectory;
+    if (aFile.isSymlink()) {
+      linkedDirectory = aFile.clone();
+      try {
+        linkedDirectory.normalize();
+      } catch (e) {
+        logger.warn("Symbolic link " + aFile.path + " points to a path" +
+             " which does not exist");
+        return null;
+      }
+    }
+    else {
+      let fis = Cc["@mozilla.org/network/file-input-stream;1"].
+                createInstance(Ci.nsIFileInputStream);
+      fis.init(aFile, -1, -1, false);
+      let line = { value: "" };
+      if (fis instanceof Ci.nsILineInputStream)
+        fis.readLine(line);
+      fis.close();
+      if (line.value) {
+        linkedDirectory = Cc["@mozilla.org/file/local;1"].
+                              createInstance(Ci.nsIFile);
+
+        try {
+          linkedDirectory.initWithPath(line.value);
+        }
+        catch (e) {
+          linkedDirectory.setRelativeDescriptor(aFile.parent, line.value);
+        }
+      }
+    }
+
+    if (linkedDirectory) {
+      if (!linkedDirectory.exists()) {
+        logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
+             " which does not exist");
+        return null;
+      }
+
+      if (!linkedDirectory.isDirectory()) {
+        logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
+             " which is not a directory");
+        return null;
+      }
+
+      return linkedDirectory;
+    }
+
+    logger.warn("File pointer " + aFile.path + " does not contain a path");
+    return null;
+  },
+
+  /**
+   * Finds all the add-ons installed in this location.
+   */
+  _readAddons: function() {
+    // Use a snapshot of the directory contents to avoid possible issues with
+    // iterating over a directory while removing files from it (the YAFFS2
+    // embedded filesystem has this issue, see bug 772238).
+    let entries = getDirectoryEntries(this._directory);
+    for (let entry of entries) {
+      let id = entry.leafName;
+
+      if (id == DIR_STAGE || id == DIR_TRASH)
+        continue;
+
+      let directLoad = false;
+      if (entry.isFile() &&
+          id.substring(id.length - 4).toLowerCase() == ".xpi") {
+        directLoad = true;
+        id = id.substring(0, id.length - 4);
+      }
+
+      if (!gIDTest.test(id)) {
+        logger.debug("Ignoring file entry whose name is not a valid add-on ID: " +
+             entry.path);
+        continue;
+      }
+
+      if (!directLoad && (entry.isFile() || entry.isSymlink())) {
+        let newEntry = this._readDirectoryFromFile(entry);
+        if (!newEntry) {
+          logger.debug("Deleting stale pointer file " + entry.path);
+          try {
+            entry.remove(true);
+          }
+          catch (e) {
+            logger.warn("Failed to remove stale pointer file " + entry.path, e);
+            // Failing to remove the stale pointer file is ignorable
+          }
+          continue;
+        }
+
+        entry = newEntry;
+        this._linkedAddons.push(id);
+      }
+
+      this._IDToFileMap[id] = entry;
+      XPIProvider._addURIMapping(id, entry);
+    }
+  },
+
+  /**
+   * Gets the name of this install location.
+   */
+  get name() {
+    return this._name;
+  },
+
+  /**
+   * Gets the scope of this install location.
+   */
+  get scope() {
+    return this._scope;
+  },
+
+  /**
+   * Gets an array of nsIFiles for add-ons installed in this location.
+   */
+  getAddonLocations: function() {
+    let locations = new Map();
+    for (let id in this._IDToFileMap) {
+      locations.set(id, this._IDToFileMap[id].clone());
+    }
+    return locations;
+  },
+
+  /**
+   * Gets the directory that the add-on with the given ID is installed in.
+   *
+   * @param  aId
+   *         The ID of the add-on
+   * @return The nsIFile
+   * @throws if the ID does not match any of the add-ons installed
+   */
+  getLocationForID: function(aId) {
+    if (aId in this._IDToFileMap)
+      return this._IDToFileMap[aId].clone();
+    throw new Error("Unknown add-on ID " + aId);
+  },
+
+  /**
+   * Returns true if the given addon was installed in this location by a text
+   * file pointing to its real path.
+   *
+   * @param aId
+   *        The ID of the addon
+   */
+  isLinkedAddon: function(aId) {
+    return this._linkedAddons.indexOf(aId) != -1;
+  }
+};
+
+/**
+ * An extension of DirectoryInstallLocation which adds methods to installing
+ * and removing add-ons from the directory at runtime.
+ *
+ * @param  aName
+ *         The string identifier for the install location
+ * @param  aDirectory
+ *         The nsIFile directory for the install location
+ * @param  aScope
+ *         The scope of add-ons installed in this location
+ */
+function MutableDirectoryInstallLocation(aName, aDirectory, aScope) {
+  DirectoryInstallLocation.call(this, aName, aDirectory, aScope);
+  this.locked = false;
+  this._stagingDirLock = 0;
+}
+
+MutableDirectoryInstallLocation.prototype = Object.create(DirectoryInstallLocation.prototype);
+Object.assign(MutableDirectoryInstallLocation.prototype, {
+  /**
+   * Gets the staging directory to put add-ons that are pending install and
+   * uninstall into.
+   *
+   * @return an nsIFile
+   */
+  getStagingDir: function() {
+    let dir = this._directory.clone();
+    dir.append(DIR_STAGE);
+    return dir;
+  },
+
+  requestStagingDir: function() {
+    this._stagingDirLock++;
+
+    if (this._stagingDirPromise)
+      return this._stagingDirPromise;
+
+    OS.File.makeDir(this._directory.path);
+    let stagepath = OS.Path.join(this._directory.path, DIR_STAGE);
+    return this._stagingDirPromise = OS.File.makeDir(stagepath).then(null, (e) => {
+      if (e instanceof OS.File.Error && e.becauseExists)
+        return;
+      logger.error("Failed to create staging directory", e);
+      throw e;
+    });
+  },
+
+  releaseStagingDir: function() {
+    this._stagingDirLock--;
+
+    if (this._stagingDirLock == 0) {
+      this._stagingDirPromise = null;
+      this.cleanStagingDir();
+    }
+
+    return Promise.resolve();
+  },
+
+  /**
+   * Removes the specified files or directories in the staging directory and
+   * then if the staging directory is empty attempts to remove it.
+   *
+   * @param  aLeafNames
+   *         An array of file or directory to remove from the directory, the
+   *         array may be empty
+   */
+  cleanStagingDir: function(aLeafNames = []) {
+    let dir = this.getStagingDir();
+
+    for (let name of aLeafNames) {
+      let file = dir.clone();
+      file.append(name);
+      recursiveRemove(file);
+    }
+
+    if (this._stagingDirLock > 0)
+      return;
+
+    let dirEntries = dir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
+    try {
+      if (dirEntries.nextFile)
+        return;
+    }
+    finally {
+      dirEntries.close();
+    }
+
+    try {
+      setFilePermissions(dir, FileUtils.PERMS_DIRECTORY);
+      dir.remove(false);
+    }
+    catch (e) {
+      logger.warn("Failed to remove staging dir", e);
+      // Failing to remove the staging directory is ignorable
+    }
+  },
+
+  /**
+   * Returns a directory that is normally on the same filesystem as the rest of
+   * the install location and can be used for temporarily storing files during
+   * safe move operations. Calling this method will delete the existing trash
+   * directory and its contents.
+   *
+   * @return an nsIFile
+   */
+  getTrashDir: function() {
+    let trashDir = this._directory.clone();
+    trashDir.append(DIR_TRASH);
+    let trashDirExists = trashDir.exists();
+    try {
+      if (trashDirExists)
+        recursiveRemove(trashDir);
+      trashDirExists = false;
+    } catch (e) {
+      logger.warn("Failed to remove trash directory", e);
+    }
+    if (!trashDirExists)
+      trashDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+
+    return trashDir;
+  },
+
+  /**
+   * Installs an add-on into the install location.
+   *
+   * @param  id
+   *         The ID of the add-on to install
+   * @param  source
+   *         The source nsIFile to install from
+   * @param  existingAddonID
+   *         The ID of an existing add-on to uninstall at the same time
+   * @param  action
+   *         What to we do with the given source file:
+   *           "move"
+   *           Default action, the source files will be moved to the new
+   *           location,
+   *           "copy"
+   *           The source files will be copied,
+   *           "proxy"
+   *           A "proxy file" is going to refer to the source file path
+   * @return an nsIFile indicating where the add-on was installed to
+   */
+  installAddon: function({ id, source, existingAddonID, action = "move" }) {
+    let trashDir = this.getTrashDir();
+
+    let transaction = new SafeInstallOperation();
+
+    let moveOldAddon = aId => {
+      let file = this._directory.clone();
+      file.append(aId);
+
+      if (file.exists())
+        transaction.moveUnder(file, trashDir);
+
+      file = this._directory.clone();
+      file.append(aId + ".xpi");
+      if (file.exists()) {
+        flushJarCache(file);
+        transaction.moveUnder(file, trashDir);
+      }
+    }
+
+    // If any of these operations fails the finally block will clean up the
+    // temporary directory
+    try {
+      moveOldAddon(id);
+      if (existingAddonID && existingAddonID != id) {
+        moveOldAddon(existingAddonID);
+
+        {
+          // Move the data directories.
+          /* XXX ajvincent We can't use OS.File:  installAddon isn't compatible
+           * with Promises, nor is SafeInstallOperation.  Bug 945540 has been filed
+           * for porting to OS.File.
+           */
+          let oldDataDir = FileUtils.getDir(
+            KEY_PROFILEDIR, ["extension-data", existingAddonID], false, true
+          );
+
+          if (oldDataDir.exists()) {
+            let newDataDir = FileUtils.getDir(
+              KEY_PROFILEDIR, ["extension-data", id], false, true
+            );
+            if (newDataDir.exists()) {
+              let trashData = trashDir.clone();
+              trashData.append("data-directory");
+              transaction.moveUnder(newDataDir, trashData);
+            }
+
+            transaction.moveTo(oldDataDir, newDataDir);
+          }
+        }
+      }
+
+      if (action == "copy") {
+        transaction.copy(source, this._directory);
+      }
+      else if (action == "move") {
+        if (source.isFile())
+          flushJarCache(source);
+
+        transaction.moveUnder(source, this._directory);
+      }
+      // Do nothing for the proxy file as we sideload an addon permanently
+    }
+    finally {
+      // It isn't ideal if this cleanup fails but it isn't worth rolling back
+      // the install because of it.
+      try {
+        recursiveRemove(trashDir);
+      }
+      catch (e) {
+        logger.warn("Failed to remove trash directory when installing " + id, e);
+      }
+    }
+
+    let newFile = this._directory.clone();
+
+    if (action == "proxy") {
+      // When permanently installing sideloaded addon, we just put a proxy file
+      // refering to the addon sources
+      newFile.append(id);
+
+      writeStringToFile(newFile, source.path);
+    } else {
+      newFile.append(source.leafName);
+    }
+
+    try {
+      newFile.lastModifiedTime = Date.now();
+    } catch (e)  {
+      logger.warn("failed to set lastModifiedTime on " + newFile.path, e);
+    }
+    this._IDToFileMap[id] = newFile;
+    XPIProvider._addURIMapping(id, newFile);
+
+    if (existingAddonID && existingAddonID != id &&
+        existingAddonID in this._IDToFileMap) {
+      delete this._IDToFileMap[existingAddonID];
+    }
+
+    return newFile;
+  },
+
+  /**
+   * Uninstalls an add-on from this location.
+   *
+   * @param  aId
+   *         The ID of the add-on to uninstall
+   * @throws if the ID does not match any of the add-ons installed
+   */
+  uninstallAddon: function(aId) {
+    let file = this._IDToFileMap[aId];
+    if (!file) {
+      logger.warn("Attempted to remove " + aId + " from " +
+           this._name + " but it was already gone");
+      return;
+    }
+
+    file = this._directory.clone();
+    file.append(aId);
+    if (!file.exists())
+      file.leafName += ".xpi";
+
+    if (!file.exists()) {
+      logger.warn("Attempted to remove " + aId + " from " +
+           this._name + " but it was already gone");
+
+      delete this._IDToFileMap[aId];
+      return;
+    }
+
+    let trashDir = this.getTrashDir();
+
+    if (file.leafName != aId) {
+      logger.debug("uninstallAddon: flushing jar cache " + file.path + " for addon " + aId);
+      flushJarCache(file);
+    }
+
+    let transaction = new SafeInstallOperation();
+
+    try {
+      transaction.moveUnder(file, trashDir);
+    }
+    finally {
+      // It isn't ideal if this cleanup fails, but it is probably better than
+      // rolling back the uninstall at this point
+      try {
+        recursiveRemove(trashDir);
+      }
+      catch (e) {
+        logger.warn("Failed to remove trash directory when uninstalling " + aId, e);
+      }
+    }
+
+    delete this._IDToFileMap[aId];
+  },
+});
+
+/**
+ * An object which identifies a directory install location for system add-ons
+ * upgrades.
+ *
+ * The location consists of a directory which contains the add-ons installed.
+ *
+ * @param  aName
+ *         The string identifier for the install location
+ * @param  aDirectory
+ *         The nsIFile directory for the install location
+ * @param  aScope
+ *         The scope of add-ons installed in this location
+ * @param  aResetSet
+ *         True to throw away the current add-on set
+ */
+function SystemAddonInstallLocation(aName, aDirectory, aScope, aResetSet) {
+  this._baseDir = aDirectory;
+  this._nextDir = null;
+
+  this._stagingDirLock = 0;
+
+  if (aResetSet)
+    this.resetAddonSet();
+
+  this._addonSet = this._loadAddonSet();
+
+  this._directory = null;
+  if (this._addonSet.directory) {
+    this._directory = aDirectory.clone();
+    this._directory.append(this._addonSet.directory);
+    logger.info("SystemAddonInstallLocation scanning directory " + this._directory.path);
+  }
+  else {
+    logger.info("SystemAddonInstallLocation directory is missing");
+  }
+
+  DirectoryInstallLocation.call(this, aName, this._directory, aScope);
+  this.locked = false;
+}
+
+SystemAddonInstallLocation.prototype = Object.create(DirectoryInstallLocation.prototype);
+Object.assign(SystemAddonInstallLocation.prototype, {
+  /**
+   * Removes the specified files or directories in the staging directory and
+   * then if the staging directory is empty attempts to remove it.
+   *
+   * @param  aLeafNames
+   *         An array of file or directory to remove from the directory, the
+   *         array may be empty
+   */
+  cleanStagingDir: function(aLeafNames = []) {
+    let dir = this.getStagingDir();
+
+    for (let name of aLeafNames) {
+      let file = dir.clone();
+      file.append(name);
+      recursiveRemove(file);
+    }
+
+    if (this._stagingDirLock > 0)
+      return;
+
+    let dirEntries = dir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
+    try {
+      if (dirEntries.nextFile)
+        return;
+    }
+    finally {
+      dirEntries.close();
+    }
+
+    try {
+      setFilePermissions(dir, FileUtils.PERMS_DIRECTORY);
+      dir.remove(false);
+    }
+    catch (e) {
+      logger.warn("Failed to remove staging dir", e);
+      // Failing to remove the staging directory is ignorable
+    }
+  },
+
+  /**
+   * Gets the staging directory to put add-ons that are pending install and
+   * uninstall into.
+   *
+   * @return {nsIFile} - staging directory for system add-on upgrades.
+   */
+  getStagingDir: function() {
+    this._addonSet = this._loadAddonSet();
+    let dir = null;
+    if (this._addonSet.directory) {
+      this._directory = this._baseDir.clone();
+      this._directory.append(this._addonSet.directory);
+      dir = this._directory.clone();
+      dir.append(DIR_STAGE);
+    }
+    else {
+      logger.info("SystemAddonInstallLocation directory is missing");
+    }
+
+    return dir;
+  },
+
+  requestStagingDir: function() {
+    this._stagingDirLock++;
+    if (this._stagingDirPromise)
+      return this._stagingDirPromise;
+
+    this._addonSet = this._loadAddonSet();
+    if (this._addonSet.directory) {
+      this._directory = this._baseDir.clone();
+      this._directory.append(this._addonSet.directory);
+    }
+
+    OS.File.makeDir(this._directory.path);
+    let stagepath = OS.Path.join(this._directory.path, DIR_STAGE);
+    return this._stagingDirPromise = OS.File.makeDir(stagepath).then(null, (e) => {
+      if (e instanceof OS.File.Error && e.becauseExists)
+        return;
+      logger.error("Failed to create staging directory", e);
+      throw e;
+    });
+  },
+
+  releaseStagingDir: function() {
+    this._stagingDirLock--;
+
+    if (this._stagingDirLock == 0) {
+      this._stagingDirPromise = null;
+      this.cleanStagingDir();
+    }
+
+    return Promise.resolve();
+  },
+
+  /**
+   * Reads the current set of system add-ons
+   */
+  _loadAddonSet: function() {
+    try {
+      let setStr = Preferences.get(PREF_SYSTEM_ADDON_SET, null);
+      if (setStr) {
+        let addonSet = JSON.parse(setStr);
+        if ((typeof addonSet == "object") && addonSet.schema == 1)
+          return addonSet;
+      }
+    }
+    catch (e) {
+      logger.error("Malformed system add-on set, resetting.");
+    }
+
+    return { schema: 1, addons: {} };
+  },
+
+  /**
+   * Saves the current set of system add-ons
+   *
+   * @param {Object} aAddonSet - object containing schema, directory and set
+   *                 of system add-on IDs and versions.
+   */
+  _saveAddonSet: function(aAddonSet) {
+    Preferences.set(PREF_SYSTEM_ADDON_SET, JSON.stringify(aAddonSet));
+  },
+
+  getAddonLocations: function() {
+    // Updated system add-ons are ignored in safe mode
+    if (Services.appinfo.inSafeMode)
+      return new Map();
+
+    let addons = DirectoryInstallLocation.prototype.getAddonLocations.call(this);
+
+    // Strip out any unexpected add-ons from the list
+    for (let id of addons.keys()) {
+      if (!(id in this._addonSet.addons))
+        addons.delete(id);
+    }
+
+    return addons;
+  },
+
+  /**
+   * Tests whether updated system add-ons are expected.
+   */
+  isActive: function() {
+    return this._directory != null;
+  },
+
+  isValidAddon: function(aAddon) {
+    if (aAddon.appDisabled) {
+      logger.warn(`System add-on ${aAddon.id} isn't compatible with the application.`);
+      return false;
+    }
+
+    if (aAddon.unpack) {
+      logger.warn(`System add-on ${aAddon.id} isn't a packed add-on.`);
+      return false;
+    }
+
+    if (!aAddon.bootstrap) {
+      logger.warn(`System add-on ${aAddon.id} isn't restartless.`);
+      return false;
+    }
+
+    if (!aAddon.multiprocessCompatible) {
+      logger.warn(`System add-on ${aAddon.id} isn't multiprocess compatible.`);
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Tests whether the loaded add-on information matches what is expected.
+   */
+  isValid: function(aAddons) {
+    for (let id of Object.keys(this._addonSet.addons)) {
+      if (!aAddons.has(id)) {
+        logger.warn(`Expected add-on ${id} is missing from the system add-on location.`);
+        return false;
+      }
+
+      let addon = aAddons.get(id);
+      if (addon.version != this._addonSet.addons[id].version) {
+        logger.warn(`Expected system add-on ${id} to be version ${this._addonSet.addons[id].version} but was ${addon.version}.`);
+        return false;
+      }
+
+      if (!this.isValidAddon(addon))
+        return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Resets the add-on set so on the next startup the default set will be used.
+   */
+  resetAddonSet: function() {
+
+    if (this._addonSet) {
+      logger.info("Removing all system add-on upgrades.");
+
+      // remove everything from the pref first, if uninstall
+      // fails then at least they will not be re-activated on
+      // next restart.
+      this._saveAddonSet({ schema: 1, addons: {} });
+
+      for (let id of Object.keys(this._addonSet.addons)) {
+        AddonManager.getAddonByID(id, addon => {
+          if (addon) {
+            addon.uninstall();
+          }
+        });
+      }
+    }
+  },
+
+  /**
+   * Removes any directories not currently in use or pending use after a
+   * restart. Any errors that happen here don't really matter as we'll attempt
+   * to cleanup again next time.
+   */
+  cleanDirectories: Task.async(function*() {
+
+    // System add-ons directory does not exist
+    if (!(yield OS.File.exists(this._baseDir.path))) {
+      return;
+    }
+
+    let iterator;
+    try {
+      iterator = new OS.File.DirectoryIterator(this._baseDir.path);
+    }
+    catch (e) {
+      logger.error("Failed to clean updated system add-ons directories.", e);
+      return;
+    }
+
+    try {
+      let entries = [];
+
+      yield iterator.forEach(entry => {
+        // Skip the directory currently in use
+        if (this._directory && this._directory.path == entry.path)
+          return;
+
+        // Skip the next directory
+        if (this._nextDir && this._nextDir.path == entry.path)
+          return;
+
+        entries.push(entry);
+      });
+
+      for (let entry of entries) {
+        if (entry.isDir) {
+          yield OS.File.removeDir(entry.path, {
+            ignoreAbsent: true,
+            ignorePermissions: true,
+          });
+        }
+        else {
+          yield OS.File.remove(entry.path, {
+            ignoreAbsent: true,
+          });
+        }
+      }
+    }
+    catch (e) {
+      logger.error("Failed to clean updated system add-ons directories.", e);
+    }
+    finally {
+      iterator.close();
+    }
+  }),
+
+  /**
+   * Installs a new set of system add-ons into the location and updates the
+   * add-on set in prefs.
+   *
+   * @param {Array} aAddons - An array of addons to install.
+   */
+  installAddonSet: Task.async(function*(aAddons) {
+    // Make sure the base dir exists
+    yield OS.File.makeDir(this._baseDir.path, { ignoreExisting: true });
+
+    let addonSet = this._loadAddonSet();
+
+    // Remove any add-ons that are no longer part of the set.
+    for (let addonID of Object.keys(addonSet.addons)) {
+      if (!aAddons.includes(addonID)) {
+        AddonManager.getAddonByID(addonID, a => a.uninstall());
+      }
+    }
+
+    let newDir = this._baseDir.clone();
+
+    let uuidGen = Cc["@mozilla.org/uuid-generator;1"].
+                  getService(Ci.nsIUUIDGenerator);
+    newDir.append("blank");
+
+    while (true) {
+      newDir.leafName = uuidGen.generateUUID().toString();
+
+      try {
+        yield OS.File.makeDir(newDir.path, { ignoreExisting: false });
+        break;
+      }
+      catch (e) {
+        logger.debug("Could not create new system add-on updates dir, retrying", e);
+      }
+    }
+
+    // Record the new upgrade directory.
+    let state = { schema: 1, directory: newDir.leafName, addons: {} };
+    this._saveAddonSet(state);
+
+    this._nextDir = newDir;
+    let location = this;
+
+    let installs = [];
+    for (let addon of aAddons) {
+      let install = yield createLocalInstall(addon._sourceBundle, location);
+      installs.push(install);
+    }
+
+    let installAddon = Task.async(function*(install) {
+      // Make the new install own its temporary file.
+      install.ownsTempFile = true;
+      install.install();
+    });
+
+    let postponeAddon = Task.async(function*(install) {
+      let resumeFn;
+      if (AddonManagerPrivate.hasUpgradeListener(install.addon.id)) {
+        logger.info(`system add-on ${install.addon.id} has an upgrade listener, postponing upgrade set until restart`);
+        resumeFn = () => {
+          logger.info(`${install.addon.id} has resumed a previously postponed addon set`);
+          install.installLocation.resumeAddonSet(installs);
+        }
+      }
+      yield install.postpone(resumeFn);
+    });
+
+    let previousState;
+
+    try {
+      // All add-ons in position, create the new state and store it in prefs
+      state = { schema: 1, directory: newDir.leafName, addons: {} };
+      for (let addon of aAddons) {
+        state.addons[addon.id] = {
+          version: addon.version
+        }
+      }
+
+      previousState = this._loadAddonSet();
+      this._saveAddonSet(state);
+
+      let blockers = aAddons.filter(
+        addon => AddonManagerPrivate.hasUpgradeListener(addon.id)
+      );
+
+      if (blockers.length > 0) {
+        yield waitForAllPromises(installs.map(postponeAddon));
+      } else {
+        yield waitForAllPromises(installs.map(installAddon));
+      }
+    }
+    catch (e) {
+      // Roll back to previous upgrade set (if present) on restart.
+      if (previousState) {
+        this._saveAddonSet(previousState);
+      }
+      // Otherwise, roll back to built-in set on restart.
+      // TODO try to do these restartlessly
+      this.resetAddonSet();
+
+      try {
+        yield OS.File.removeDir(newDir.path, { ignorePermissions: true });
+      }
+      catch (e) {
+        logger.warn(`Failed to remove failed system add-on directory ${newDir.path}.`, e);
+      }
+      throw e;
+    }
+  }),
+
+ /**
+  * Resumes upgrade of a previously-delayed add-on set.
+  */
+  resumeAddonSet: Task.async(function*(installs) {
+    let resumeAddon = Task.async(function*(install) {
+      install.state = AddonManager.STATE_DOWNLOADED;
+      install.installLocation.releaseStagingDir();
+      install.install();
+    });
+
+    let addonSet = this._loadAddonSet();
+    let addonIDs = Object.keys(addonSet.addons);
+
+    let blockers = installs.filter(
+      install => AddonManagerPrivate.hasUpgradeListener(install.addon.id)
+    );
+
+    if (blockers.length > 1) {
+      logger.warn("Attempted to resume system add-on install but upgrade blockers are still present");
+    } else {
+      yield waitForAllPromises(installs.map(resumeAddon));
+    }
+  }),
+
+  /**
+   * Returns a directory that is normally on the same filesystem as the rest of
+   * the install location and can be used for temporarily storing files during
+   * safe move operations. Calling this method will delete the existing trash
+   * directory and its contents.
+   *
+   * @return an nsIFile
+   */
+  getTrashDir: function() {
+    let trashDir = this._directory.clone();
+    trashDir.append(DIR_TRASH);
+    let trashDirExists = trashDir.exists();
+    try {
+      if (trashDirExists)
+        recursiveRemove(trashDir);
+      trashDirExists = false;
+    } catch (e) {
+      logger.warn("Failed to remove trash directory", e);
+    }
+    if (!trashDirExists)
+      trashDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
+
+    return trashDir;
+  },
+
+  /**
+   * Installs an add-on into the install location.
+   *
+   * @param  id
+   *         The ID of the add-on to install
+   * @param  source
+   *         The source nsIFile to install from
+   * @return an nsIFile indicating where the add-on was installed to
+   */
+  installAddon: function({id, source}) {
+    let trashDir = this.getTrashDir();
+    let transaction = new SafeInstallOperation();
+
+    // If any of these operations fails the finally block will clean up the
+    // temporary directory
+    try {
+      if (source.isFile()) {
+        flushJarCache(source);
+      }
+
+      transaction.moveUnder(source, this._directory);
+    }
+    finally {
+      // It isn't ideal if this cleanup fails but it isn't worth rolling back
+      // the install because of it.
+      try {
+        recursiveRemove(trashDir);
+      }
+      catch (e) {
+        logger.warn("Failed to remove trash directory when installing " + id, e);
+      }
+    }
+
+    let newFile = this._directory.clone();
+    newFile.append(source.leafName);
+
+    try {
+      newFile.lastModifiedTime = Date.now();
+    } catch (e)  {
+      logger.warn("failed to set lastModifiedTime on " + newFile.path, e);
+    }
+    this._IDToFileMap[id] = newFile;
+    XPIProvider._addURIMapping(id, newFile);
+
+    return newFile;
+  },
+
+  // old system add-on upgrade dirs get automatically removed
+  uninstallAddon: (aAddon) => {},
+});
+
+/**
+ * An object which identifies an install location for temporary add-ons.
+ */
+const TemporaryInstallLocation = {
+  locked: false,
+  name: KEY_APP_TEMPORARY,
+  scope: AddonManager.SCOPE_TEMPORARY,
+  getAddonLocations: () => [],
+  isLinkedAddon: () => false,
+  installAddon: () => {},
+  uninstallAddon: (aAddon) => {},
+  getStagingDir: () => {},
+}
+
+/**
+ * An object that identifies a registry install location for add-ons. The location
+ * consists of a registry key which contains string values mapping ID to the
+ * path where an add-on is installed
+ *
+ * @param  aName
+ *         The string identifier of this Install Location.
+ * @param  aRootKey
+ *         The root key (one of the ROOT_KEY_ values from nsIWindowsRegKey).
+ * @param  scope
+ *         The scope of add-ons installed in this location
+ */
+function WinRegInstallLocation(aName, aRootKey, aScope) {
+  this.locked = true;
+  this._name = aName;
+  this._rootKey = aRootKey;
+  this._scope = aScope;
+  this._IDToFileMap = {};
+
+  let path = this._appKeyPath + "\\Extensions";
+  let key = Cc["@mozilla.org/windows-registry-key;1"].
+            createInstance(Ci.nsIWindowsRegKey);
+
+  // Reading the registry may throw an exception, and that's ok.  In error
+  // cases, we just leave ourselves in the empty state.
+  try {
+    key.open(this._rootKey, path, Ci.nsIWindowsRegKey.ACCESS_READ);
+  }
+  catch (e) {
+    return;
+  }
+
+  this._readAddons(key);
+  key.close();
+}
+
+WinRegInstallLocation.prototype = {
+  _name       : "",
+  _rootKey    : null,
+  _scope      : null,
+  _IDToFileMap : null,  // mapping from ID to nsIFile
+
+  /**
+   * Retrieves the path of this Application's data key in the registry.
+   */
+  get _appKeyPath() {
+    let appVendor = Services.appinfo.vendor;
+    let appName = Services.appinfo.name;
+
+    // XXX Thunderbird doesn't specify a vendor string
+    if (AppConstants.MOZ_APP_NAME == "thunderbird" && appVendor == "")
+      appVendor = "Mozilla";
+
+    // XULRunner-based apps may intentionally not specify a vendor
+    if (appVendor != "")
+      appVendor += "\\";
+
+    return "SOFTWARE\\" + appVendor + appName;
+  },
+
+  /**
+   * Read the registry and build a mapping between ID and path for each
+   * installed add-on.
+   *
+   * @param  key
+   *         The key that contains the ID to path mapping
+   */
+  _readAddons: function(aKey) {
+    let count = aKey.valueCount;
+    for (let i = 0; i < count; ++i) {
+      let id = aKey.getValueName(i);
+
+      let file = new nsIFile(aKey.readStringValue(id));
+
+      if (!file.exists()) {
+        logger.warn("Ignoring missing add-on in " + file.path);
+        continue;
+      }
+
+      this._IDToFileMap[id] = file;
+      XPIProvider._addURIMapping(id, file);
+    }
+  },
+
+  /**
+   * Gets the name of this install location.
+   */
+  get name() {
+    return this._name;
+  },
+
+  /**
+   * Gets the scope of this install location.
+   */
+  get scope() {
+    return this._scope;
+  },
+
+  /**
+   * Gets an array of nsIFiles for add-ons installed in this location.
+   */
+  getAddonLocations: function() {
+    let locations = new Map();
+    for (let id in this._IDToFileMap) {
+      locations.set(id, this._IDToFileMap[id].clone());
+    }
+    return locations;
+  },
+
+  /**
+   * @see DirectoryInstallLocation
+   */
+  isLinkedAddon: function(aId) {
+    return true;
+  }
+};
+
+var addonTypes = [
+  new AddonManagerPrivate.AddonType("extension", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 4000,
+                                    AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
+  new AddonManagerPrivate.AddonType("theme", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 5000),
+  new AddonManagerPrivate.AddonType("dictionary", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 7000,
+                                    AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
+  new AddonManagerPrivate.AddonType("locale", URI_EXTENSION_STRINGS,
+                                    STRING_TYPE_NAME,
+                                    AddonManager.VIEW_TYPE_LIST, 8000,
+                                    AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
+];
+
+// We only register experiments support if the application supports them.
+// Ideally, we would install an observer to watch the pref. Installing
+// an observer for this pref is not necessary here and may be buggy with
+// regards to registering this XPIProvider twice.
+if (Preferences.get("experiments.supported", false)) {
+  addonTypes.push(
+    new AddonManagerPrivate.AddonType("experiment",
+                                      URI_EXTENSION_STRINGS,
+                                      STRING_TYPE_NAME,
+                                      AddonManager.VIEW_TYPE_LIST, 11000,
+                                      AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL));
+}
+
+AddonManagerPrivate.registerProvider(XPIProvider, addonTypes);
diff --git a/toolkit/mozapps/webextensions/internal/XPIProviderUtils.js b/toolkit/mozapps/webextensions/internal/XPIProviderUtils.js
new file mode 100644
index 000000000..d04eb207c
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/XPIProviderUtils.js
@@ -0,0 +1,2255 @@
+/* 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";
+
+// These are injected from XPIProvider.jsm
+/* globals ADDON_SIGNING, SIGNED_TYPES, BOOTSTRAP_REASONS, DB_SCHEMA,
+          AddonInternal, XPIProvider, XPIStates, syncLoadManifestFromFile,
+          isUsableAddon, recordAddonTelemetry, applyBlocklistChanges,
+          flushChromeCaches, canRunInSafeMode*/
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/AddonManager.jsm");
+/* globals AddonManagerPrivate*/
+Cu.import("resource://gre/modules/Preferences.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository",
+                                  "resource://gre/modules/addons/AddonRepository.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+                                  "resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "DeferredSave",
+                                  "resource://gre/modules/DeferredSave.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+                                  "resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+                                  "resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyServiceGetter(this, "Blocklist",
+                                   "@mozilla.org/extensions/blocklist;1",
+                                   Ci.nsIBlocklistService);
+
+Cu.import("resource://gre/modules/Log.jsm");
+const LOGGER_ID = "addons.xpi-utils";
+
+const nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile");
+
+// Create a new logger for use by the Addons XPI Provider Utils
+// (Requires AddonManager.jsm)
+var logger = Log.repository.getLogger(LOGGER_ID);
+
+const KEY_PROFILEDIR                  = "ProfD";
+const FILE_DATABASE                   = "extensions.sqlite";
+const FILE_JSON_DB                    = "extensions.json";
+const FILE_OLD_DATABASE               = "extensions.rdf";
+const FILE_XPI_ADDONS_LIST            = "extensions.ini";
+
+// The last version of DB_SCHEMA implemented in SQLITE
+const LAST_SQLITE_DB_SCHEMA           = 14;
+const PREF_DB_SCHEMA                  = "extensions.databaseSchema";
+const PREF_PENDING_OPERATIONS         = "extensions.pendingOperations";
+const PREF_EM_ENABLED_ADDONS          = "extensions.enabledAddons";
+const PREF_EM_DSS_ENABLED             = "extensions.dss.enabled";
+const PREF_EM_AUTO_DISABLED_SCOPES    = "extensions.autoDisableScopes";
+const PREF_E10S_BLOCKED_BY_ADDONS     = "extensions.e10sBlockedByAddons";
+const PREF_E10S_HAS_NONEXEMPT_ADDON   = "extensions.e10s.rollout.hasAddon";
+
+const KEY_APP_PROFILE                 = "app-profile";
+const KEY_APP_SYSTEM_ADDONS           = "app-system-addons";
+const KEY_APP_SYSTEM_DEFAULTS         = "app-system-defaults";
+const KEY_APP_GLOBAL                  = "app-global";
+
+// Properties that only exist in the database
+const DB_METADATA        = ["syncGUID",
+                            "installDate",
+                            "updateDate",
+                            "size",
+                            "sourceURI",
+                            "releaseNotesURI",
+                            "applyBackgroundUpdates"];
+const DB_BOOL_METADATA   = ["visible", "active", "userDisabled", "appDisabled",
+                            "pendingUninstall", "bootstrap", "skinnable",
+                            "softDisabled", "isForeignInstall",
+                            "hasBinaryComponents", "strictCompatibility"];
+
+// Properties to save in JSON file
+const PROP_JSON_FIELDS = ["id", "syncGUID", "location", "version", "type",
+                          "internalName", "updateURL", "updateKey", "optionsURL",
+                          "optionsType", "aboutURL", "icons", "iconURL", "icon64URL",
+                          "defaultLocale", "visible", "active", "userDisabled",
+                          "appDisabled", "pendingUninstall", "descriptor", "installDate",
+                          "updateDate", "applyBackgroundUpdates", "bootstrap",
+                          "skinnable", "size", "sourceURI", "releaseNotesURI",
+                          "softDisabled", "foreignInstall", "hasBinaryComponents",
+                          "strictCompatibility", "locales", "targetApplications",
+                          "targetPlatforms", "multiprocessCompatible", "signedState",
+                          "seen", "dependencies", "hasEmbeddedWebExtension", "mpcOptedOut"];
+
+// 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"];
+
+// Time to wait before async save of XPI JSON database, in milliseconds
+const ASYNC_SAVE_DELAY_MS = 20;
+
+const PREFIX_ITEM_URI                 = "urn:mozilla:item:";
+const RDFURI_ITEM_ROOT                = "urn:mozilla:item:root"
+const PREFIX_NS_EM                    = "http://www.mozilla.org/2004/em-rdf#";
+
+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));
+}
+
+/**
+ * Asynchronously fill in the _repositoryAddon field for one addon
+ */
+function getRepositoryAddon(aAddon, aCallback) {
+  if (!aAddon) {
+    aCallback(aAddon);
+    return;
+  }
+  function completeAddon(aRepositoryAddon) {
+    aAddon._repositoryAddon = aRepositoryAddon;
+    aAddon.compatibilityOverrides = aRepositoryAddon ?
+                                      aRepositoryAddon.compatibilityOverrides :
+                                      null;
+    aCallback(aAddon);
+  }
+  AddonRepository.getCachedAddonByID(aAddon.id, completeAddon);
+}
+
+/**
+ * Wrap an API-supplied function in an exception handler to make it safe to call
+ */
+function makeSafe(aCallback) {
+  return function(...aArgs) {
+    try {
+      aCallback(...aArgs);
+    }
+    catch (ex) {
+      logger.warn("XPI Database callback failed", ex);
+    }
+  }
+}
+
+/**
+ * A helper method to asynchronously call a function on an array
+ * of objects, calling a callback when function(x) has been gathered
+ * for every element of the array.
+ * WARNING: not currently error-safe; if the async function does not call
+ * our internal callback for any of the array elements, asyncMap will not
+ * call the callback parameter.
+ *
+ * @param  aObjects
+ *         The array of objects to process asynchronously
+ * @param  aMethod
+ *         Function with signature function(object, function(f_of_object))
+ * @param  aCallback
+ *         Function with signature f([aMethod(object)]), called when all values
+ *         are available
+ */
+function asyncMap(aObjects, aMethod, aCallback) {
+  var resultsPending = aObjects.length;
+  var results = []
+  if (resultsPending == 0) {
+    aCallback(results);
+    return;
+  }
+
+  function asyncMap_gotValue(aIndex, aValue) {
+    results[aIndex] = aValue;
+    if (--resultsPending == 0) {
+      aCallback(results);
+    }
+  }
+
+  aObjects.map(function(aObject, aIndex, aArray) {
+    try {
+      aMethod(aObject, function(aResult) {
+        asyncMap_gotValue(aIndex, aResult);
+      });
+    }
+    catch (e) {
+      logger.warn("Async map function failed", e);
+      asyncMap_gotValue(aIndex, undefined);
+    }
+  });
+}
+
+/**
+ * A generator to synchronously return result rows from an mozIStorageStatement.
+ *
+ * @param  aStatement
+ *         The statement to execute
+ */
+function* resultRows(aStatement) {
+  try {
+    while (stepStatement(aStatement))
+      yield aStatement.row;
+  }
+  finally {
+    aStatement.reset();
+  }
+}
+
+/**
+ * A helper function to log an SQL error.
+ *
+ * @param  aError
+ *         The storage error code associated with the error
+ * @param  aErrorString
+ *         An error message
+ */
+function logSQLError(aError, aErrorString) {
+  logger.error("SQL error " + aError + ": " + aErrorString);
+}
+
+/**
+ * A helper function to log any errors that occur during async statements.
+ *
+ * @param  aError
+ *         A mozIStorageError to log
+ */
+function asyncErrorLogger(aError) {
+  logSQLError(aError.result, aError.message);
+}
+
+/**
+ * A helper function to step a statement synchronously and log any error that
+ * occurs.
+ *
+ * @param  aStatement
+ *         A mozIStorageStatement to execute
+ */
+function stepStatement(aStatement) {
+  try {
+    return aStatement.executeStep();
+  }
+  catch (e) {
+    logSQLError(XPIDatabase.connection.lastError,
+                XPIDatabase.connection.lastErrorString);
+    throw e;
+  }
+}
+
+/**
+ * Copies properties from one object to another. If no target object is passed
+ * a new object will be created and returned.
+ *
+ * @param  aObject
+ *         An object to copy from
+ * @param  aProperties
+ *         An array of properties to be copied
+ * @param  aTarget
+ *         An optional target object to copy the properties to
+ * @return the object that the properties were copied onto
+ */
+function copyProperties(aObject, aProperties, aTarget) {
+  if (!aTarget)
+    aTarget = {};
+  aProperties.forEach(function(aProp) {
+    if (aProp in aObject)
+      aTarget[aProp] = aObject[aProp];
+  });
+  return aTarget;
+}
+
+/**
+ * Copies properties from a mozIStorageRow to an object. If no target object is
+ * passed a new object will be created and returned.
+ *
+ * @param  aRow
+ *         A mozIStorageRow to copy from
+ * @param  aProperties
+ *         An array of properties to be copied
+ * @param  aTarget
+ *         An optional target object to copy the properties to
+ * @return the object that the properties were copied onto
+ */
+function copyRowProperties(aRow, aProperties, aTarget) {
+  if (!aTarget)
+    aTarget = {};
+  aProperties.forEach(function(aProp) {
+    aTarget[aProp] = aRow.getResultByName(aProp);
+  });
+  return aTarget;
+}
+
+/**
+ * The DBAddonInternal is a special AddonInternal that has been retrieved from
+ * the database. The constructor will initialize the DBAddonInternal with a set
+ * of fields, which could come from either the JSON store or as an
+ * XPIProvider.AddonInternal created from an addon's manifest
+ * @constructor
+ * @param aLoaded
+ *        Addon data fields loaded from JSON or the addon manifest.
+ */
+function DBAddonInternal(aLoaded) {
+  AddonInternal.call(this);
+
+  copyProperties(aLoaded, PROP_JSON_FIELDS, this);
+
+  if (!this.dependencies)
+    this.dependencies = [];
+  Object.freeze(this.dependencies);
+
+  if (aLoaded._installLocation) {
+    this._installLocation = aLoaded._installLocation;
+    this.location = aLoaded._installLocation.name;
+  }
+  else if (aLoaded.location) {
+    this._installLocation = XPIProvider.installLocationsByName[this.location];
+  }
+
+  this._key = this.location + ":" + this.id;
+
+  if (!aLoaded._sourceBundle) {
+    throw new Error("Expected passed argument to contain a descriptor");
+  }
+
+  this._sourceBundle = aLoaded._sourceBundle;
+
+  XPCOMUtils.defineLazyGetter(this, "pendingUpgrade", function() {
+      for (let install of XPIProvider.installs) {
+        if (install.state == AddonManager.STATE_INSTALLED &&
+            !(install.addon.inDatabase) &&
+            install.addon.id == this.id &&
+            install.installLocation == this._installLocation) {
+          delete this.pendingUpgrade;
+          return this.pendingUpgrade = install.addon;
+        }
+      }
+      return null;
+    });
+}
+
+DBAddonInternal.prototype = Object.create(AddonInternal.prototype);
+Object.assign(DBAddonInternal.prototype, {
+  applyCompatibilityUpdate: function(aUpdate, aSyncCompatibility) {
+    let wasCompatible = this.isCompatible;
+
+    this.targetApplications.forEach(function(aTargetApp) {
+      aUpdate.targetApplications.forEach(function(aUpdateTarget) {
+        if (aTargetApp.id == aUpdateTarget.id && (aSyncCompatibility ||
+            Services.vc.compare(aTargetApp.maxVersion, aUpdateTarget.maxVersion) < 0)) {
+          aTargetApp.minVersion = aUpdateTarget.minVersion;
+          aTargetApp.maxVersion = aUpdateTarget.maxVersion;
+          XPIDatabase.saveChanges();
+        }
+      });
+    });
+    if (aUpdate.multiprocessCompatible !== undefined &&
+        aUpdate.multiprocessCompatible != this.multiprocessCompatible) {
+      this.multiprocessCompatible = aUpdate.multiprocessCompatible;
+      XPIDatabase.saveChanges();
+    }
+
+    if (wasCompatible != this.isCompatible)
+      XPIProvider.updateAddonDisabledState(this);
+  },
+
+  toJSON: function() {
+    let jsonData = copyProperties(this, PROP_JSON_FIELDS);
+
+    // Experiments are serialized as disabled so they aren't run on the next
+    // startup.
+    if (this.type == "experiment") {
+      jsonData.userDisabled = true;
+      jsonData.active = false;
+    }
+
+    return jsonData;
+  },
+
+  get inDatabase() {
+    return true;
+  }
+});
+
+/**
+ * Internal interface: find an addon from an already loaded addonDB
+ */
+function _findAddon(addonDB, aFilter) {
+  for (let addon of addonDB.values()) {
+    if (aFilter(addon)) {
+      return addon;
+    }
+  }
+  return null;
+}
+
+/**
+ * Internal interface to get a filtered list of addons from a loaded addonDB
+ */
+function _filterDB(addonDB, aFilter) {
+  return Array.from(addonDB.values()).filter(aFilter);
+}
+
+this.XPIDatabase = {
+  // true if the database connection has been opened
+  initialized: false,
+  // The database file
+  jsonFile: FileUtils.getFile(KEY_PROFILEDIR, [FILE_JSON_DB], true),
+  // Migration data loaded from an old version of the database.
+  migrateData: null,
+  // Active add-on directories loaded from extensions.ini and prefs at startup.
+  activeBundles: null,
+
+  // Saved error object if we fail to read an existing database
+  _loadError: null,
+
+  // Error reported by our most recent attempt to read or write the database, if any
+  get lastError() {
+    if (this._loadError)
+      return this._loadError;
+    if (this._deferredSave)
+      return this._deferredSave.lastError;
+    return null;
+  },
+
+  /**
+   * Mark the current stored data dirty, and schedule a flush to disk
+   */
+  saveChanges: function() {
+    if (!this.initialized) {
+      throw new Error("Attempt to use XPI database when it is not initialized");
+    }
+
+    if (XPIProvider._closing) {
+      // use an Error here so we get a stack trace.
+      let err = new Error("XPI database modified after shutdown began");
+      logger.warn(err);
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_late_stack", Log.stackTrace(err));
+    }
+
+    if (!this._deferredSave) {
+      this._deferredSave = new DeferredSave(this.jsonFile.path,
+                                            () => JSON.stringify(this),
+                                            ASYNC_SAVE_DELAY_MS);
+    }
+
+    this.updateAddonsBlockingE10s();
+    let promise = this._deferredSave.saveChanges();
+    if (!this._schemaVersionSet) {
+      this._schemaVersionSet = true;
+      promise = promise.then(
+        count => {
+          // Update the XPIDB schema version preference the first time we successfully
+          // save the database.
+          logger.debug("XPI Database saved, setting schema version preference to " + DB_SCHEMA);
+          Services.prefs.setIntPref(PREF_DB_SCHEMA, DB_SCHEMA);
+          // Reading the DB worked once, so we don't need the load error
+          this._loadError = null;
+        },
+        error => {
+          // Need to try setting the schema version again later
+          this._schemaVersionSet = false;
+          // this._deferredSave.lastError has the most recent error so we don't
+          // need this any more
+          this._loadError = null;
+
+          throw error;
+        });
+    }
+
+    promise.catch(error => {
+      logger.warn("Failed to save XPI database", error);
+    });
+  },
+
+  flush: function() {
+    // handle the "in memory only" and "saveChanges never called" cases
+    if (!this._deferredSave) {
+      return Promise.resolve(0);
+    }
+
+    return this._deferredSave.flush();
+  },
+
+  /**
+   * Converts the current internal state of the XPI addon database to
+   * a JSON.stringify()-ready structure
+   */
+  toJSON: function() {
+    if (!this.addonDB) {
+      // We never loaded the database?
+      throw new Error("Attempt to save database without loading it first");
+    }
+
+    let toSave = {
+      schemaVersion: DB_SCHEMA,
+      addons: [...this.addonDB.values()]
+    };
+    return toSave;
+  },
+
+  /**
+   * Pull upgrade information from an existing SQLITE database
+   *
+   * @return false if there is no SQLITE database
+   *         true and sets this.migrateData to null if the SQLITE DB exists
+   *              but does not contain useful information
+   *         true and sets this.migrateData to
+   *              {location: {id1:{addon1}, id2:{addon2}}, location2:{...}, ...}
+   *              if there is useful information
+   */
+  getMigrateDataFromSQLITE: function() {
+    let connection = null;
+    let dbfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true);
+    // Attempt to open the database
+    try {
+      connection = Services.storage.openUnsharedDatabase(dbfile);
+    }
+    catch (e) {
+      logger.warn("Failed to open sqlite database " + dbfile.path + " for upgrade", e);
+      return null;
+    }
+    logger.debug("Migrating data from sqlite");
+    let migrateData = this.getMigrateDataFromDatabase(connection);
+    connection.close();
+    return migrateData;
+  },
+
+  /**
+   * Synchronously opens and reads the database file, upgrading from old
+   * databases or making a new DB if needed.
+   *
+   * The possibilities, in order of priority, are:
+   * 1) Perfectly good, up to date database
+   * 2) Out of date JSON database needs to be upgraded => upgrade
+   * 3) JSON database exists but is mangled somehow => build new JSON
+   * 4) no JSON DB, but a useable SQLITE db we can upgrade from => upgrade
+   * 5) useless SQLITE DB => build new JSON
+   * 6) useable RDF DB => upgrade
+   * 7) useless RDF DB => build new JSON
+   * 8) Nothing at all => build new JSON
+   * @param  aRebuildOnError
+   *         A boolean indicating whether add-on information should be loaded
+   *         from the install locations if the database needs to be rebuilt.
+   *         (if false, caller is XPIProvider.checkForChanges() which will rebuild)
+   */
+  syncLoadDB: function(aRebuildOnError) {
+    this.migrateData = null;
+    let fstream = null;
+    let data = "";
+    try {
+      let readTimer = AddonManagerPrivate.simpleTimer("XPIDB_syncRead_MS");
+      logger.debug("Opening XPI database " + this.jsonFile.path);
+      fstream = Components.classes["@mozilla.org/network/file-input-stream;1"].
+              createInstance(Components.interfaces.nsIFileInputStream);
+      fstream.init(this.jsonFile, -1, 0, 0);
+      let cstream = null;
+      try {
+        cstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"].
+                createInstance(Components.interfaces.nsIConverterInputStream);
+        cstream.init(fstream, "UTF-8", 0, 0);
+
+        let str = {};
+        let read = 0;
+        do {
+          read = cstream.readString(0xffffffff, str); // read as much as we can and put it in str.value
+          data += str.value;
+        } while (read != 0);
+
+        readTimer.done();
+        this.parseDB(data, aRebuildOnError);
+      }
+      catch (e) {
+        logger.error("Failed to load XPI JSON data from profile", e);
+        let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildReadFailed_MS");
+        this.rebuildDatabase(aRebuildOnError);
+        rebuildTimer.done();
+      }
+      finally {
+        if (cstream)
+          cstream.close();
+      }
+    }
+    catch (e) {
+      if (e.result === Cr.NS_ERROR_FILE_NOT_FOUND) {
+        this.upgradeDB(aRebuildOnError);
+      }
+      else {
+        this.rebuildUnreadableDB(e, aRebuildOnError);
+      }
+    }
+    finally {
+      if (fstream)
+        fstream.close();
+    }
+    // If an async load was also in progress, resolve that promise with our DB;
+    // otherwise create a resolved promise
+    if (this._dbPromise) {
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_overlapped_load", 1);
+      this._dbPromise.resolve(this.addonDB);
+    }
+    else
+      this._dbPromise = Promise.resolve(this.addonDB);
+  },
+
+  /**
+   * Parse loaded data, reconstructing the database if the loaded data is not valid
+   * @param aRebuildOnError
+   *        If true, synchronously reconstruct the database from installed add-ons
+   */
+  parseDB: function(aData, aRebuildOnError) {
+    let parseTimer = AddonManagerPrivate.simpleTimer("XPIDB_parseDB_MS");
+    try {
+      // dump("Loaded JSON:\n" + aData + "\n");
+      let inputAddons = JSON.parse(aData);
+      // Now do some sanity checks on our JSON db
+      if (!("schemaVersion" in inputAddons) || !("addons" in inputAddons)) {
+        parseTimer.done();
+        // Content of JSON file is bad, need to rebuild from scratch
+        logger.error("bad JSON file contents");
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "badJSON");
+        let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildBadJSON_MS");
+        this.rebuildDatabase(aRebuildOnError);
+        rebuildTimer.done();
+        return;
+      }
+      if (inputAddons.schemaVersion != DB_SCHEMA) {
+        // Handle mismatched JSON schema version. For now, we assume
+        // compatibility for JSON data, though we throw away any fields we
+        // don't know about (bug 902956)
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError",
+                                                "schemaMismatch-" + inputAddons.schemaVersion);
+        logger.debug("JSON schema mismatch: expected " + DB_SCHEMA +
+            ", actual " + inputAddons.schemaVersion);
+        // When we rev the schema of the JSON database, we need to make sure we
+        // force the DB to save so that the DB_SCHEMA value in the JSON file and
+        // the preference are updated.
+      }
+      // If we got here, we probably have good data
+      // Make AddonInternal instances from the loaded data and save them
+      let addonDB = new Map();
+      for (let loadedAddon of inputAddons.addons) {
+        loadedAddon._sourceBundle = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+        try {
+          loadedAddon._sourceBundle.persistentDescriptor = loadedAddon.descriptor;
+        }
+        catch (e) {
+          // We can fail here when the descriptor is invalid, usually from the
+          // wrong OS
+          logger.warn("Could not find source bundle for add-on " + loadedAddon.id, e);
+        }
+
+        let newAddon = new DBAddonInternal(loadedAddon);
+        addonDB.set(newAddon._key, newAddon);
+      }
+      parseTimer.done();
+      this.addonDB = addonDB;
+      logger.debug("Successfully read XPI database");
+      this.initialized = true;
+    }
+    catch (e) {
+      // If we catch and log a SyntaxError from the JSON
+      // parser, the xpcshell test harness fails the test for us: bug 870828
+      parseTimer.done();
+      if (e.name == "SyntaxError") {
+        logger.error("Syntax error parsing saved XPI JSON data");
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "syntax");
+      }
+      else {
+        logger.error("Failed to load XPI JSON data from profile", e);
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "other");
+      }
+      let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildReadFailed_MS");
+      this.rebuildDatabase(aRebuildOnError);
+      rebuildTimer.done();
+    }
+  },
+
+  /**
+   * Upgrade database from earlier (sqlite or RDF) version if available
+   */
+  upgradeDB: function(aRebuildOnError) {
+    let upgradeTimer = AddonManagerPrivate.simpleTimer("XPIDB_upgradeDB_MS");
+    try {
+      let schemaVersion = Services.prefs.getIntPref(PREF_DB_SCHEMA);
+      if (schemaVersion <= LAST_SQLITE_DB_SCHEMA) {
+        // we should have an older SQLITE database
+        logger.debug("Attempting to upgrade from SQLITE database");
+        this.migrateData = this.getMigrateDataFromSQLITE();
+      }
+      else {
+        // we've upgraded before but the JSON file is gone, fall through
+        // and rebuild from scratch
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "dbMissing");
+      }
+    }
+    catch (e) {
+      // No schema version pref means either a really old upgrade (RDF) or
+      // a new profile
+      this.migrateData = this.getMigrateDataFromRDF();
+    }
+
+    this.rebuildDatabase(aRebuildOnError);
+    upgradeTimer.done();
+  },
+
+  /**
+   * Reconstruct when the DB file exists but is unreadable
+   * (for example because read permission is denied)
+   */
+  rebuildUnreadableDB: function(aError, aRebuildOnError) {
+    let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildUnreadableDB_MS");
+    logger.warn("Extensions database " + this.jsonFile.path +
+        " exists but is not readable; rebuilding", aError);
+    // Remember the error message until we try and write at least once, so
+    // we know at shutdown time that there was a problem
+    this._loadError = aError;
+    AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "unreadable");
+    this.rebuildDatabase(aRebuildOnError);
+    rebuildTimer.done();
+  },
+
+  /**
+   * Open and read the XPI database asynchronously, upgrading if
+   * necessary. If any DB load operation fails, we need to
+   * synchronously rebuild the DB from the installed extensions.
+   *
+   * @return Promise<Map> resolves to the Map of loaded JSON data stored
+   *         in this.addonDB; never rejects.
+   */
+  asyncLoadDB: function() {
+    // Already started (and possibly finished) loading
+    if (this._dbPromise) {
+      return this._dbPromise;
+    }
+
+    logger.debug("Starting async load of XPI database " + this.jsonFile.path);
+    AddonManagerPrivate.recordSimpleMeasure("XPIDB_async_load", XPIProvider.runPhase);
+    let readOptions = {
+      outExecutionDuration: 0
+    };
+    return this._dbPromise = OS.File.read(this.jsonFile.path, null, readOptions).then(
+      byteArray => {
+        logger.debug("Async JSON file read took " + readOptions.outExecutionDuration + " MS");
+        AddonManagerPrivate.recordSimpleMeasure("XPIDB_asyncRead_MS",
+          readOptions.outExecutionDuration);
+        if (this._addonDB) {
+          logger.debug("Synchronous load completed while waiting for async load");
+          return this.addonDB;
+        }
+        logger.debug("Finished async read of XPI database, parsing...");
+        let decodeTimer = AddonManagerPrivate.simpleTimer("XPIDB_decode_MS");
+        let decoder = new TextDecoder();
+        let data = decoder.decode(byteArray);
+        decodeTimer.done();
+        this.parseDB(data, true);
+        return this.addonDB;
+      })
+    .then(null,
+      error => {
+        if (this._addonDB) {
+          logger.debug("Synchronous load completed while waiting for async load");
+          return this.addonDB;
+        }
+        if (error.becauseNoSuchFile) {
+          this.upgradeDB(true);
+        }
+        else {
+          // it's there but unreadable
+          this.rebuildUnreadableDB(error, true);
+        }
+        return this.addonDB;
+      });
+  },
+
+  /**
+   * Rebuild the database from addon install directories. If this.migrateData
+   * is available, uses migrated information for settings on the addons found
+   * during rebuild
+   * @param aRebuildOnError
+   *         A boolean indicating whether add-on information should be loaded
+   *         from the install locations if the database needs to be rebuilt.
+   *         (if false, caller is XPIProvider.checkForChanges() which will rebuild)
+   */
+  rebuildDatabase: function(aRebuildOnError) {
+    this.addonDB = new Map();
+    this.initialized = true;
+
+    if (XPIStates.size == 0) {
+      // No extensions installed, so we're done
+      logger.debug("Rebuilding XPI database with no extensions");
+      return;
+    }
+
+    // If there is no migration data then load the list of add-on directories
+    // that were active during the last run
+    if (!this.migrateData)
+      this.activeBundles = this.getActiveBundles();
+
+    if (aRebuildOnError) {
+      logger.warn("Rebuilding add-ons database from installed extensions.");
+      try {
+        XPIDatabaseReconcile.processFileChanges({}, false);
+      }
+      catch (e) {
+        logger.error("Failed to rebuild XPI database from installed extensions", e);
+      }
+      // Make sure to update the active add-ons and add-ons list on shutdown
+      Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+    }
+  },
+
+  /**
+   * Gets the list of file descriptors of active extension directories or XPI
+   * files from the add-ons list. This must be loaded from disk since the
+   * directory service gives no easy way to get both directly. This list doesn't
+   * include themes as preferences already say which theme is currently active
+   *
+   * @return an array of persistent descriptors for the directories
+   */
+  getActiveBundles: function() {
+    let bundles = [];
+
+    // non-bootstrapped extensions
+    let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST],
+                                       true);
+
+    if (!addonsList.exists())
+      // XXX Irving believes this is broken in the case where there is no
+      // extensions.ini but there are bootstrap extensions (e.g. Android)
+      return null;
+
+    try {
+      let iniFactory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"]
+                         .getService(Ci.nsIINIParserFactory);
+      let parser = iniFactory.createINIParser(addonsList);
+      let keys = parser.getKeys("ExtensionDirs");
+
+      while (keys.hasMore())
+        bundles.push(parser.getString("ExtensionDirs", keys.getNext()));
+    }
+    catch (e) {
+      logger.warn("Failed to parse extensions.ini", e);
+      return null;
+    }
+
+    // Also include the list of active bootstrapped extensions
+    for (let id in XPIProvider.bootstrappedAddons)
+      bundles.push(XPIProvider.bootstrappedAddons[id].descriptor);
+
+    return bundles;
+  },
+
+  /**
+   * Retrieves migration data from the old extensions.rdf database.
+   *
+   * @return an object holding information about what add-ons were previously
+   *         userDisabled and any updated compatibility information
+   */
+  getMigrateDataFromRDF: function(aDbWasMissing) {
+
+    // Migrate data from extensions.rdf
+    let rdffile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_DATABASE], true);
+    if (!rdffile.exists())
+      return null;
+
+    logger.debug("Migrating data from " + FILE_OLD_DATABASE);
+    let migrateData = {};
+
+    try {
+      let ds = gRDF.GetDataSourceBlocking(Services.io.newFileURI(rdffile).spec);
+      let root = Cc["@mozilla.org/rdf/container;1"].
+                 createInstance(Ci.nsIRDFContainer);
+      root.Init(ds, gRDF.GetResource(RDFURI_ITEM_ROOT));
+      let elements = root.GetElements();
+
+      while (elements.hasMoreElements()) {
+        let source = elements.getNext().QueryInterface(Ci.nsIRDFResource);
+
+        let location = getRDFProperty(ds, source, "installLocation");
+        if (location) {
+          if (!(location in migrateData))
+            migrateData[location] = {};
+          let id = source.ValueUTF8.substring(PREFIX_ITEM_URI.length);
+          migrateData[location][id] = {
+            version: getRDFProperty(ds, source, "version"),
+            userDisabled: false,
+            targetApplications: []
+          }
+
+          let disabled = getRDFProperty(ds, source, "userDisabled");
+          if (disabled == "true" || disabled == "needs-disable")
+            migrateData[location][id].userDisabled = true;
+
+          let targetApps = ds.GetTargets(source, EM_R("targetApplication"),
+                                         true);
+          while (targetApps.hasMoreElements()) {
+            let targetApp = targetApps.getNext()
+                                      .QueryInterface(Ci.nsIRDFResource);
+            let appInfo = {
+              id: getRDFProperty(ds, targetApp, "id")
+            };
+
+            let minVersion = getRDFProperty(ds, targetApp, "updatedMinVersion");
+            if (minVersion) {
+              appInfo.minVersion = minVersion;
+              appInfo.maxVersion = getRDFProperty(ds, targetApp, "updatedMaxVersion");
+            }
+            else {
+              appInfo.minVersion = getRDFProperty(ds, targetApp, "minVersion");
+              appInfo.maxVersion = getRDFProperty(ds, targetApp, "maxVersion");
+            }
+            migrateData[location][id].targetApplications.push(appInfo);
+          }
+        }
+      }
+    }
+    catch (e) {
+      logger.warn("Error reading " + FILE_OLD_DATABASE, e);
+      migrateData = null;
+    }
+
+    return migrateData;
+  },
+
+  /**
+   * Retrieves migration data from a database that has an older or newer schema.
+   *
+   * @return an object holding information about what add-ons were previously
+   *         userDisabled and any updated compatibility information
+   */
+  getMigrateDataFromDatabase: function(aConnection) {
+    let migrateData = {};
+
+    // Attempt to migrate data from a different (even future!) version of the
+    // database
+    try {
+      var stmt = aConnection.createStatement("PRAGMA table_info(addon)");
+
+      const REQUIRED = ["internal_id", "id", "location", "userDisabled",
+                        "installDate", "version"];
+
+      let reqCount = 0;
+      let props = [];
+      for (let row of resultRows(stmt)) {
+        if (REQUIRED.indexOf(row.name) != -1) {
+          reqCount++;
+          props.push(row.name);
+        }
+        else if (DB_METADATA.indexOf(row.name) != -1) {
+          props.push(row.name);
+        }
+        else if (DB_BOOL_METADATA.indexOf(row.name) != -1) {
+          props.push(row.name);
+        }
+      }
+
+      if (reqCount < REQUIRED.length) {
+        logger.error("Unable to read anything useful from the database");
+        return null;
+      }
+      stmt.finalize();
+
+      stmt = aConnection.createStatement("SELECT " + props.join(",") + " FROM addon");
+      for (let row of resultRows(stmt)) {
+        if (!(row.location in migrateData))
+          migrateData[row.location] = {};
+        let addonData = {
+          targetApplications: []
+        }
+        migrateData[row.location][row.id] = addonData;
+
+        props.forEach(function(aProp) {
+          if (aProp == "isForeignInstall")
+            addonData.foreignInstall = (row[aProp] == 1);
+          if (DB_BOOL_METADATA.indexOf(aProp) != -1)
+            addonData[aProp] = row[aProp] == 1;
+          else
+            addonData[aProp] = row[aProp];
+        })
+      }
+
+      var taStmt = aConnection.createStatement("SELECT id, minVersion, " +
+                                                   "maxVersion FROM " +
+                                                   "targetApplication WHERE " +
+                                                   "addon_internal_id=:internal_id");
+
+      for (let location in migrateData) {
+        for (let id in migrateData[location]) {
+          taStmt.params.internal_id = migrateData[location][id].internal_id;
+          delete migrateData[location][id].internal_id;
+          for (let row of resultRows(taStmt)) {
+            migrateData[location][id].targetApplications.push({
+              id: row.id,
+              minVersion: row.minVersion,
+              maxVersion: row.maxVersion
+            });
+          }
+        }
+      }
+    }
+    catch (e) {
+      // An error here means the schema is too different to read
+      logger.error("Error migrating data", e);
+      return null;
+    }
+    finally {
+      if (taStmt)
+        taStmt.finalize();
+      if (stmt)
+        stmt.finalize();
+    }
+
+    return migrateData;
+  },
+
+  /**
+   * Shuts down the database connection and releases all cached objects.
+   * Return: Promise{integer} resolves / rejects with the result of the DB
+   *                          flush after the database is flushed and
+   *                          all cleanup is done
+   */
+  shutdown: function() {
+    logger.debug("shutdown");
+    if (this.initialized) {
+      // If our last database I/O had an error, try one last time to save.
+      if (this.lastError)
+        this.saveChanges();
+
+      this.initialized = false;
+
+      if (this._deferredSave) {
+        AddonManagerPrivate.recordSimpleMeasure(
+            "XPIDB_saves_total", this._deferredSave.totalSaves);
+        AddonManagerPrivate.recordSimpleMeasure(
+            "XPIDB_saves_overlapped", this._deferredSave.overlappedSaves);
+        AddonManagerPrivate.recordSimpleMeasure(
+            "XPIDB_saves_late", this._deferredSave.dirty ? 1 : 0);
+      }
+
+      // Return a promise that any pending writes of the DB are complete and we
+      // are finished cleaning up
+      let flushPromise = this.flush();
+      flushPromise.then(null, error => {
+          logger.error("Flush of XPI database failed", error);
+          AddonManagerPrivate.recordSimpleMeasure("XPIDB_shutdownFlush_failed", 1);
+          // If our last attempt to read or write the DB failed, force a new
+          // extensions.ini to be written to disk on the next startup
+          Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+        })
+        .then(count => {
+          // Clear out the cached addons data loaded from JSON
+          delete this.addonDB;
+          delete this._dbPromise;
+          // same for the deferred save
+          delete this._deferredSave;
+          // re-enable the schema version setter
+          delete this._schemaVersionSet;
+        });
+      return flushPromise;
+    }
+    return Promise.resolve(0);
+  },
+
+  /**
+   * Asynchronously list all addons that match the filter function
+   * @param  aFilter
+   *         Function that takes an addon instance and returns
+   *         true if that addon should be included in the selected array
+   * @param  aCallback
+   *         Called back with an array of addons matching aFilter
+   *         or an empty array if none match
+   */
+  getAddonList: function(aFilter, aCallback) {
+    this.asyncLoadDB().then(
+      addonDB => {
+        let addonList = _filterDB(addonDB, aFilter);
+        asyncMap(addonList, getRepositoryAddon, makeSafe(aCallback));
+      })
+    .then(null,
+        error => {
+          logger.error("getAddonList failed", error);
+          makeSafe(aCallback)([]);
+        });
+  },
+
+  /**
+   * (Possibly asynchronously) get the first addon that matches the filter function
+   * @param  aFilter
+   *         Function that takes an addon instance and returns
+   *         true if that addon should be selected
+   * @param  aCallback
+   *         Called back with the addon, or null if no matching addon is found
+   */
+  getAddon: function(aFilter, aCallback) {
+    return this.asyncLoadDB().then(
+      addonDB => {
+        getRepositoryAddon(_findAddon(addonDB, aFilter), makeSafe(aCallback));
+      })
+    .then(null,
+        error => {
+          logger.error("getAddon failed", error);
+          makeSafe(aCallback)(null);
+        });
+  },
+
+  /**
+   * Asynchronously gets an add-on with a particular ID in a particular
+   * install location.
+   *
+   * @param  aId
+   *         The ID of the add-on to retrieve
+   * @param  aLocation
+   *         The name of the install location
+   * @param  aCallback
+   *         A callback to pass the DBAddonInternal to
+   */
+  getAddonInLocation: function(aId, aLocation, aCallback) {
+    this.asyncLoadDB().then(
+        addonDB => getRepositoryAddon(addonDB.get(aLocation + ":" + aId),
+                                      makeSafe(aCallback)));
+  },
+
+  /**
+   * Asynchronously get all the add-ons in a particular install location.
+   *
+   * @param  aLocation
+   *         The name of the install location
+   * @param  aCallback
+   *         A callback to pass the array of DBAddonInternals to
+   */
+  getAddonsInLocation: function(aLocation, aCallback) {
+    this.getAddonList(aAddon => aAddon._installLocation.name == aLocation, aCallback);
+  },
+
+  /**
+   * Asynchronously gets the add-on with the specified ID that is visible.
+   *
+   * @param  aId
+   *         The ID of the add-on to retrieve
+   * @param  aCallback
+   *         A callback to pass the DBAddonInternal to
+   */
+  getVisibleAddonForID: function(aId, aCallback) {
+    this.getAddon(aAddon => ((aAddon.id == aId) && aAddon.visible),
+                  aCallback);
+  },
+
+  /**
+   * Asynchronously gets the visible add-ons, optionally restricting by type.
+   *
+   * @param  aTypes
+   *         An array of types to include or null to include all types
+   * @param  aCallback
+   *         A callback to pass the array of DBAddonInternals to
+   */
+  getVisibleAddons: function(aTypes, aCallback) {
+    this.getAddonList(aAddon => (aAddon.visible &&
+                                 (!aTypes || (aTypes.length == 0) ||
+                                  (aTypes.indexOf(aAddon.type) > -1))),
+                      aCallback);
+  },
+
+  /**
+   * Synchronously gets all add-ons of a particular type.
+   *
+   * @param  aType
+   *         The type of add-on to retrieve
+   * @return an array of DBAddonInternals
+   */
+  getAddonsByType: function(aType) {
+    if (!this.addonDB) {
+      // jank-tastic! Must synchronously load DB if the theme switches from
+      // an XPI theme to a lightweight theme before the DB has loaded,
+      // because we're called from sync XPIProvider.addonChanged
+      logger.warn("Synchronous load of XPI database due to getAddonsByType(" + aType + ")");
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_byType", XPIProvider.runPhase);
+      this.syncLoadDB(true);
+    }
+    return _filterDB(this.addonDB, aAddon => (aAddon.type == aType));
+  },
+
+  /**
+   * Synchronously gets an add-on with a particular internalName.
+   *
+   * @param  aInternalName
+   *         The internalName of the add-on to retrieve
+   * @return a DBAddonInternal
+   */
+  getVisibleAddonForInternalName: function(aInternalName) {
+    if (!this.addonDB) {
+      // This may be called when the DB hasn't otherwise been loaded
+      logger.warn("Synchronous load of XPI database due to getVisibleAddonForInternalName");
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_forInternalName",
+          XPIProvider.runPhase);
+      this.syncLoadDB(true);
+    }
+
+    return _findAddon(this.addonDB,
+                      aAddon => aAddon.visible &&
+                                (aAddon.internalName == aInternalName));
+  },
+
+  /**
+   * Asynchronously gets all add-ons with pending operations.
+   *
+   * @param  aTypes
+   *         The types of add-ons to retrieve or null to get all types
+   * @param  aCallback
+   *         A callback to pass the array of DBAddonInternal to
+   */
+  getVisibleAddonsWithPendingOperations: function(aTypes, aCallback) {
+    this.getAddonList(
+        aAddon => (aAddon.visible &&
+                   (aAddon.pendingUninstall ||
+                    // Logic here is tricky. If we're active but disabled,
+                    // we're pending disable; !active && !disabled, we're pending enable
+                    (aAddon.active == aAddon.disabled)) &&
+                   (!aTypes || (aTypes.length == 0) || (aTypes.indexOf(aAddon.type) > -1))),
+        aCallback);
+  },
+
+  /**
+   * Asynchronously get an add-on by its Sync GUID.
+   *
+   * @param  aGUID
+   *         Sync GUID of add-on to fetch
+   * @param  aCallback
+   *         A callback to pass the DBAddonInternal record to. Receives null
+   *         if no add-on with that GUID is found.
+   *
+   */
+  getAddonBySyncGUID: function(aGUID, aCallback) {
+    this.getAddon(aAddon => aAddon.syncGUID == aGUID,
+                  aCallback);
+  },
+
+  /**
+   * Synchronously gets all add-ons in the database.
+   * This is only called from the preference observer for the default
+   * compatibility version preference, so we can return an empty list if
+   * we haven't loaded the database yet.
+   *
+   * @return  an array of DBAddonInternals
+   */
+  getAddons: function() {
+    if (!this.addonDB) {
+      return [];
+    }
+    return _filterDB(this.addonDB, aAddon => true);
+  },
+
+  /**
+   * Synchronously adds an AddonInternal's metadata to the database.
+   *
+   * @param  aAddon
+   *         AddonInternal to add
+   * @param  aDescriptor
+   *         The file descriptor of the add-on
+   * @return The DBAddonInternal that was added to the database
+   */
+  addAddonMetadata: function(aAddon, aDescriptor) {
+    if (!this.addonDB) {
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_addMetadata",
+          XPIProvider.runPhase);
+      this.syncLoadDB(false);
+    }
+
+    let newAddon = new DBAddonInternal(aAddon);
+    newAddon.descriptor = aDescriptor;
+    this.addonDB.set(newAddon._key, newAddon);
+    if (newAddon.visible) {
+      this.makeAddonVisible(newAddon);
+    }
+
+    this.saveChanges();
+    return newAddon;
+  },
+
+  /**
+   * Synchronously updates an add-on's metadata in the database. Currently just
+   * removes and recreates.
+   *
+   * @param  aOldAddon
+   *         The DBAddonInternal to be replaced
+   * @param  aNewAddon
+   *         The new AddonInternal to add
+   * @param  aDescriptor
+   *         The file descriptor of the add-on
+   * @return The DBAddonInternal that was added to the database
+   */
+  updateAddonMetadata: function(aOldAddon, aNewAddon, aDescriptor) {
+    this.removeAddonMetadata(aOldAddon);
+    aNewAddon.syncGUID = aOldAddon.syncGUID;
+    aNewAddon.installDate = aOldAddon.installDate;
+    aNewAddon.applyBackgroundUpdates = aOldAddon.applyBackgroundUpdates;
+    aNewAddon.foreignInstall = aOldAddon.foreignInstall;
+    aNewAddon.seen = aOldAddon.seen;
+    aNewAddon.active = (aNewAddon.visible && !aNewAddon.disabled && !aNewAddon.pendingUninstall);
+
+    // addAddonMetadata does a saveChanges()
+    return this.addAddonMetadata(aNewAddon, aDescriptor);
+  },
+
+  /**
+   * Synchronously removes an add-on from the database.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal being removed
+   */
+  removeAddonMetadata: function(aAddon) {
+    this.addonDB.delete(aAddon._key);
+    this.saveChanges();
+  },
+
+  /**
+   * Synchronously marks a DBAddonInternal as visible marking all other
+   * instances with the same ID as not visible.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal to make visible
+   */
+  makeAddonVisible: function(aAddon) {
+    logger.debug("Make addon " + aAddon._key + " visible");
+    for (let [, otherAddon] of this.addonDB) {
+      if ((otherAddon.id == aAddon.id) && (otherAddon._key != aAddon._key)) {
+        logger.debug("Hide addon " + otherAddon._key);
+        otherAddon.visible = false;
+        otherAddon.active = false;
+      }
+    }
+    aAddon.visible = true;
+    this.saveChanges();
+  },
+
+  /**
+   * Synchronously sets properties for an add-on.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal being updated
+   * @param  aProperties
+   *         A dictionary of properties to set
+   */
+  setAddonProperties: function(aAddon, aProperties) {
+    for (let key in aProperties) {
+      aAddon[key] = aProperties[key];
+    }
+    this.saveChanges();
+  },
+
+  /**
+   * Synchronously sets the Sync GUID for an add-on.
+   * Only called when the database is already loaded.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal being updated
+   * @param  aGUID
+   *         GUID string to set the value to
+   * @throws if another addon already has the specified GUID
+   */
+  setAddonSyncGUID: function(aAddon, aGUID) {
+    // Need to make sure no other addon has this GUID
+    function excludeSyncGUID(otherAddon) {
+      return (otherAddon._key != aAddon._key) && (otherAddon.syncGUID == aGUID);
+    }
+    let otherAddon = _findAddon(this.addonDB, excludeSyncGUID);
+    if (otherAddon) {
+      throw new Error("Addon sync GUID conflict for addon " + aAddon._key +
+          ": " + otherAddon._key + " already has GUID " + aGUID);
+    }
+    aAddon.syncGUID = aGUID;
+    this.saveChanges();
+  },
+
+  /**
+   * Synchronously updates an add-on's active flag in the database.
+   *
+   * @param  aAddon
+   *         The DBAddonInternal to update
+   */
+  updateAddonActive: function(aAddon, aActive) {
+    logger.debug("Updating active state for add-on " + aAddon.id + " to " + aActive);
+
+    aAddon.active = aActive;
+    this.saveChanges();
+  },
+
+  updateAddonsBlockingE10s: function() {
+    let blockE10s = false;
+
+    Preferences.set(PREF_E10S_HAS_NONEXEMPT_ADDON, false);
+    for (let [, addon] of this.addonDB) {
+      let active = (addon.visible && !addon.disabled && !addon.pendingUninstall);
+
+      if (active && XPIProvider.isBlockingE10s(addon)) {
+        blockE10s = true;
+        break;
+      }
+    }
+    Preferences.set(PREF_E10S_BLOCKED_BY_ADDONS, blockE10s);
+  },
+
+  /**
+   * Synchronously calculates and updates all the active flags in the database.
+   */
+  updateActiveAddons: function() {
+    if (!this.addonDB) {
+      logger.warn("updateActiveAddons called when DB isn't loaded");
+      // force the DB to load
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_updateActive",
+          XPIProvider.runPhase);
+      this.syncLoadDB(true);
+    }
+    logger.debug("Updating add-on states");
+    for (let [, addon] of this.addonDB) {
+      let newActive = (addon.visible && !addon.disabled && !addon.pendingUninstall);
+      if (newActive != addon.active) {
+        addon.active = newActive;
+        this.saveChanges();
+      }
+    }
+  },
+
+  /**
+   * Writes out the XPI add-ons list for the platform to read.
+   * @return true if the file was successfully updated, false otherwise
+   */
+  writeAddonsList: function() {
+    if (!this.addonDB) {
+      // force the DB to load
+      AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_writeList",
+          XPIProvider.runPhase);
+      this.syncLoadDB(true);
+    }
+    Services.appinfo.invalidateCachesOnRestart();
+
+    let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST],
+                                       true);
+    let enabledAddons = [];
+    let text = "[ExtensionDirs]\r\n";
+    let count = 0;
+    let fullCount = 0;
+
+    let activeAddons = _filterDB(
+      this.addonDB,
+      aAddon => aAddon.active && !aAddon.bootstrap && (aAddon.type != "theme"));
+
+    for (let row of activeAddons) {
+      text += "Extension" + (count++) + "=" + row.descriptor + "\r\n";
+      enabledAddons.push(encodeURIComponent(row.id) + ":" +
+                         encodeURIComponent(row.version));
+    }
+    fullCount += count;
+
+    // The selected skin may come from an inactive theme (the default theme
+    // when a lightweight theme is applied for example)
+    text += "\r\n[ThemeDirs]\r\n";
+
+    let dssEnabled = false;
+    try {
+      dssEnabled = Services.prefs.getBoolPref(PREF_EM_DSS_ENABLED);
+    } catch (e) {}
+
+    let themes = [];
+    if (dssEnabled) {
+      themes = _filterDB(this.addonDB, aAddon => aAddon.type == "theme");
+    }
+    else {
+      let activeTheme = _findAddon(
+        this.addonDB,
+        aAddon => (aAddon.type == "theme") &&
+                  (aAddon.internalName == XPIProvider.selectedSkin));
+      if (activeTheme) {
+        themes.push(activeTheme);
+      }
+    }
+
+    if (themes.length > 0) {
+      count = 0;
+      for (let row of themes) {
+        text += "Extension" + (count++) + "=" + row.descriptor + "\r\n";
+        enabledAddons.push(encodeURIComponent(row.id) + ":" +
+                           encodeURIComponent(row.version));
+      }
+      fullCount += count;
+    }
+
+    text += "\r\n[MultiprocessIncompatibleExtensions]\r\n";
+
+    count = 0;
+    for (let row of activeAddons) {
+      if (!row.multiprocessCompatible) {
+        text += "Extension" + (count++) + "=" + row.id + "\r\n";
+      }
+    }
+
+    if (fullCount > 0) {
+      logger.debug("Writing add-ons list");
+
+      try {
+        let addonsListTmp = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST + ".tmp"],
+                                              true);
+        var fos = FileUtils.openFileOutputStream(addonsListTmp);
+        fos.write(text, text.length);
+        fos.close();
+        addonsListTmp.moveTo(addonsListTmp.parent, FILE_XPI_ADDONS_LIST);
+
+        Services.prefs.setCharPref(PREF_EM_ENABLED_ADDONS, enabledAddons.join(","));
+      }
+      catch (e) {
+        logger.error("Failed to write add-ons list to profile directory", e);
+        return false;
+      }
+    }
+    else {
+      if (addonsList.exists()) {
+        logger.debug("Deleting add-ons list");
+        try {
+          addonsList.remove(false);
+        }
+        catch (e) {
+          logger.error("Failed to remove " + addonsList.path, e);
+          return false;
+        }
+      }
+
+      Services.prefs.clearUserPref(PREF_EM_ENABLED_ADDONS);
+    }
+    return true;
+  }
+};
+
+this.XPIDatabaseReconcile = {
+  /**
+   * Returns a map of ID -> add-on. When the same add-on ID exists in multiple
+   * install locations the highest priority location is chosen.
+   */
+  flattenByID(addonMap, hideLocation) {
+    let map = new Map();
+
+    for (let installLocation of XPIProvider.installLocations) {
+      if (installLocation.name == hideLocation)
+        continue;
+
+      let locationMap = addonMap.get(installLocation.name);
+      if (!locationMap)
+        continue;
+
+      for (let [id, addon] of locationMap) {
+        if (!map.has(id))
+          map.set(id, addon);
+      }
+    }
+
+    return map;
+  },
+
+  /**
+   * Finds the visible add-ons from the map.
+   */
+  getVisibleAddons(addonMap) {
+    let map = new Map();
+
+    for (let [location, addons] of addonMap) {
+      for (let [id, addon] of addons) {
+        if (!addon.visible)
+          continue;
+
+        if (map.has(id)) {
+          logger.warn("Previous database listed more than one visible add-on with id " + id);
+          continue;
+        }
+
+        map.set(id, addon);
+      }
+    }
+
+    return map;
+  },
+
+  /**
+   * Called to add the metadata for an add-on in one of the install locations
+   * to the database. This can be called in three different cases. Either an
+   * add-on has been dropped into the location from outside of Firefox, or
+   * an add-on has been installed through the application, or the database
+   * has been upgraded or become corrupt and add-on data has to be reloaded
+   * into it.
+   *
+   * @param  aInstallLocation
+   *         The install location containing the add-on
+   * @param  aId
+   *         The ID of the add-on
+   * @param  aAddonState
+   *         The new state of the add-on
+   * @param  aNewAddon
+   *         The manifest for the new add-on if it has already been loaded
+   * @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
+   * @param  aMigrateData
+   *         If during startup the database had to be upgraded this will
+   *         contain data that used to be held about this add-on
+   * @return a boolean indicating if flushing caches is required to complete
+   *         changing this add-on
+   */
+  addMetadata(aInstallLocation, aId, aAddonState, aNewAddon, aOldAppVersion,
+              aOldPlatformVersion, aMigrateData) {
+    logger.debug("New add-on " + aId + " installed in " + aInstallLocation.name);
+
+    // If we had staged data for this add-on or we aren't recovering from a
+    // corrupt database and we don't have migration data for this add-on then
+    // this must be a new install.
+    let isNewInstall = (!!aNewAddon) || (!XPIDatabase.activeBundles && !aMigrateData);
+
+    // If it's a new install and we haven't yet loaded the manifest then it
+    // must be something dropped directly into the install location
+    let isDetectedInstall = isNewInstall && !aNewAddon;
+
+    // Load the manifest if necessary and sanity check the add-on ID
+    try {
+      if (!aNewAddon) {
+        // Load the manifest from the add-on.
+        let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+        file.persistentDescriptor = aAddonState.descriptor;
+        aNewAddon = syncLoadManifestFromFile(file, aInstallLocation);
+      }
+      // The add-on in the manifest should match the add-on ID.
+      if (aNewAddon.id != aId) {
+        throw new Error("Invalid addon ID: expected addon ID " + aId +
+                        ", found " + aNewAddon.id + " in manifest");
+      }
+    }
+    catch (e) {
+      logger.warn("addMetadata: Add-on " + aId + " is invalid", e);
+
+      // Remove the invalid add-on from the install location if the install
+      // location isn't locked, no restart will be necessary
+      if (aInstallLocation.isLinkedAddon(aId))
+        logger.warn("Not uninstalling invalid item because it is a proxy file");
+      else if (aInstallLocation.locked)
+        logger.warn("Could not uninstall invalid item from locked install location");
+      else
+        aInstallLocation.uninstallAddon(aId);
+      return null;
+    }
+
+    // Update the AddonInternal properties.
+    aNewAddon.installDate = aAddonState.mtime;
+    aNewAddon.updateDate = aAddonState.mtime;
+
+    // Assume that add-ons in the system add-ons install location aren't
+    // foreign and should default to enabled.
+    aNewAddon.foreignInstall = isDetectedInstall &&
+                               aInstallLocation.name != KEY_APP_SYSTEM_ADDONS &&
+                               aInstallLocation.name != KEY_APP_SYSTEM_DEFAULTS;
+
+    // appDisabled depends on whether the add-on is a foreignInstall so update
+    aNewAddon.appDisabled = !isUsableAddon(aNewAddon);
+
+    if (aMigrateData) {
+      // If there is migration data then apply it.
+      logger.debug("Migrating data from old database");
+
+      DB_MIGRATE_METADATA.forEach(function(aProp) {
+        // A theme's disabled state is determined by the selected theme
+        // preference which is read in loadManifestFromRDF
+        if (aProp == "userDisabled" && aNewAddon.type == "theme")
+          return;
+
+        if (aProp in aMigrateData)
+          aNewAddon[aProp] = aMigrateData[aProp];
+      });
+
+      // Force all non-profile add-ons to be foreignInstalls since they can't
+      // have been installed through the API
+      aNewAddon.foreignInstall |= aInstallLocation.name != KEY_APP_PROFILE;
+
+      // Some properties should only be migrated if the add-on hasn't changed.
+      // The version property isn't a perfect check for this but covers the
+      // vast majority of cases.
+      if (aMigrateData.version == aNewAddon.version) {
+        logger.debug("Migrating compatibility info");
+        if ("targetApplications" in aMigrateData)
+          aNewAddon.applyCompatibilityUpdate(aMigrateData, true);
+      }
+
+      // Since the DB schema has changed make sure softDisabled is correct
+      applyBlocklistChanges(aNewAddon, aNewAddon, aOldAppVersion,
+                            aOldPlatformVersion);
+    }
+
+    // The default theme is never a foreign install
+    if (aNewAddon.type == "theme" && aNewAddon.internalName == XPIProvider.defaultSkin)
+      aNewAddon.foreignInstall = false;
+
+    if (isDetectedInstall && aNewAddon.foreignInstall) {
+      // If the add-on is a foreign install and is in a scope where add-ons
+      // that were dropped in should default to disabled then disable it
+      let disablingScopes = Preferences.get(PREF_EM_AUTO_DISABLED_SCOPES, 0);
+      if (aInstallLocation.scope & disablingScopes) {
+        logger.warn("Disabling foreign installed add-on " + aNewAddon.id + " in "
+            + aInstallLocation.name);
+        aNewAddon.userDisabled = true;
+
+        // If we don't have an old app version then this is a new profile in
+        // which case just mark any sideloaded add-ons as already seen.
+        aNewAddon.seen = !aOldAppVersion;
+      }
+    }
+
+    return XPIDatabase.addAddonMetadata(aNewAddon, aAddonState.descriptor);
+  },
+
+  /**
+   * Called when an add-on has been removed.
+   *
+   * @param  aOldAddon
+   *         The AddonInternal as it appeared the last time the application
+   *         ran
+   * @return a boolean indicating if flushing caches is required to complete
+   *         changing this add-on
+   */
+  removeMetadata(aOldAddon) {
+    // This add-on has disappeared
+    logger.debug("Add-on " + aOldAddon.id + " removed from " + aOldAddon.location);
+    XPIDatabase.removeAddonMetadata(aOldAddon);
+  },
+
+  /**
+   * Updates an add-on's metadata and determines if a restart of the
+   * application is necessary. This is called when either the add-on's
+   * install directory path or last modified time has changed.
+   *
+   * @param  aInstallLocation
+   *         The install location containing the add-on
+   * @param  aOldAddon
+   *         The AddonInternal as it appeared the last time the application
+   *         ran
+   * @param  aAddonState
+   *         The new state of the add-on
+   * @param  aNewAddon
+   *         The manifest for the new add-on if it has already been loaded
+   * @return a boolean indicating if flushing caches is required to complete
+   *         changing this add-on
+   */
+  updateMetadata(aInstallLocation, aOldAddon, aAddonState, aNewAddon) {
+    logger.debug("Add-on " + aOldAddon.id + " modified in " + aInstallLocation.name);
+
+    try {
+      // If there isn't an updated install manifest for this add-on then load it.
+      if (!aNewAddon) {
+        let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+        file.persistentDescriptor = aAddonState.descriptor;
+        aNewAddon = syncLoadManifestFromFile(file, aInstallLocation);
+        applyBlocklistChanges(aOldAddon, aNewAddon);
+
+        // Carry over any pendingUninstall state to add-ons modified directly
+        // in the profile. This is important when the attempt to remove the
+        // add-on in processPendingFileChanges failed and caused an mtime
+        // change to the add-ons files.
+        aNewAddon.pendingUninstall = aOldAddon.pendingUninstall;
+      }
+
+      // The ID in the manifest that was loaded must match the ID of the old
+      // add-on.
+      if (aNewAddon.id != aOldAddon.id)
+        throw new Error("Incorrect id in install manifest for existing add-on " + aOldAddon.id);
+    }
+    catch (e) {
+      logger.warn("updateMetadata: Add-on " + aOldAddon.id + " is invalid", e);
+      XPIDatabase.removeAddonMetadata(aOldAddon);
+      XPIStates.removeAddon(aOldAddon.location, aOldAddon.id);
+      if (!aInstallLocation.locked)
+        aInstallLocation.uninstallAddon(aOldAddon.id);
+      else
+        logger.warn("Could not uninstall invalid item from locked install location");
+
+      return null;
+    }
+
+    // Set the additional properties on the new AddonInternal
+    aNewAddon.updateDate = aAddonState.mtime;
+
+    // Update the database
+    return XPIDatabase.updateAddonMetadata(aOldAddon, aNewAddon, aAddonState.descriptor);
+  },
+
+  /**
+   * Updates an add-on's descriptor for when the add-on has moved in the
+   * filesystem but hasn't changed in any other way.
+   *
+   * @param  aInstallLocation
+   *         The install location containing the add-on
+   * @param  aOldAddon
+   *         The AddonInternal as it appeared the last time the application
+   *         ran
+   * @param  aAddonState
+   *         The new state of the add-on
+   * @return a boolean indicating if flushing caches is required to complete
+   *         changing this add-on
+   */
+  updateDescriptor(aInstallLocation, aOldAddon, aAddonState) {
+    logger.debug("Add-on " + aOldAddon.id + " moved to " + aAddonState.descriptor);
+    aOldAddon.descriptor = aAddonState.descriptor;
+    aOldAddon._sourceBundle.persistentDescriptor = aAddonState.descriptor;
+
+    return aOldAddon;
+  },
+
+  /**
+   * Called when no change has been detected for an add-on's metadata but the
+   * application has changed so compatibility may have changed.
+   *
+   * @param  aInstallLocation
+   *         The install location containing the add-on
+   * @param  aOldAddon
+   *         The AddonInternal as it appeared the last time the application
+   *         ran
+   * @param  aAddonState
+   *         The new state of the add-on
+   * @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
+   * @param  aReloadMetadata
+   *         A boolean which indicates whether metadata should be reloaded from
+   *         the addon manifests. Default to false.
+   * @return the new addon.
+   */
+  updateCompatibility(aInstallLocation, aOldAddon, aAddonState, aOldAppVersion,
+                      aOldPlatformVersion, aReloadMetadata) {
+    logger.debug("Updating compatibility for add-on " + aOldAddon.id + " in " + aInstallLocation.name);
+
+    // If updating from a version of the app that didn't support signedState
+    // then fetch that property now
+    if (aOldAddon.signedState === undefined && ADDON_SIGNING &&
+        SIGNED_TYPES.has(aOldAddon.type)) {
+      let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+      file.persistentDescriptor = aAddonState.descriptor;
+      let manifest = syncLoadManifestFromFile(file, aInstallLocation);
+      aOldAddon.signedState = manifest.signedState;
+    }
+
+    // May be updating from a version of the app that didn't support all the
+    // properties of the currently-installed add-ons.
+    if (aReloadMetadata) {
+      let file = new nsIFile()
+      file.persistentDescriptor = aAddonState.descriptor;
+      let manifest = syncLoadManifestFromFile(file, aInstallLocation);
+
+      // Avoid re-reading these properties from manifest,
+      // use existing addon instead.
+      // TODO - consider re-scanning for targetApplications.
+      let remove = ["syncGUID", "foreignInstall", "visible", "active",
+                    "userDisabled", "applyBackgroundUpdates", "sourceURI",
+                    "releaseNotesURI", "targetApplications"];
+
+      let props = PROP_JSON_FIELDS.filter(a => !remove.includes(a));
+      copyProperties(manifest, props, aOldAddon);
+    }
+
+    // This updates the addon's JSON cached data in place
+    applyBlocklistChanges(aOldAddon, aOldAddon, aOldAppVersion,
+                          aOldPlatformVersion);
+    aOldAddon.appDisabled = !isUsableAddon(aOldAddon);
+
+    return aOldAddon;
+  },
+
+  /**
+   * 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.
+   * Always called after XPIProviderUtils.js and extensions.json have been loaded.
+   *
+   * @param  aManifests
+   *         A dictionary of cached AddonInstalls for add-ons that have been
+   *         installed
+   * @param  aUpdateCompatibility
+   *         true to update add-ons appDisabled property when the application
+   *         version has changed
+   * @param  aOldAppVersion
+   *         The version of the application last run with this profile or null
+   *         if it is a new profile or the version is unknown
+   * @param  aOldPlatformVersion
+   *         The version of the platform last run with this profile or null
+   *         if it is a new profile or the version is unknown
+   * @param  aSchemaChange
+   *         The schema has changed and all add-on manifests should be re-read.
+   * @return a boolean indicating if a change requiring flushing the caches was
+   *         detected
+   */
+  processFileChanges(aManifests, aUpdateCompatibility, aOldAppVersion, aOldPlatformVersion,
+                     aSchemaChange) {
+    let loadedManifest = (aInstallLocation, aId) => {
+      if (!(aInstallLocation.name in aManifests))
+        return null;
+      if (!(aId in aManifests[aInstallLocation.name]))
+        return null;
+      return aManifests[aInstallLocation.name][aId];
+    };
+
+    // Add-ons loaded from the database can have an uninitialized _sourceBundle
+    // if the descriptor was invalid. Swallow that error and say they don't exist.
+    let exists = (aAddon) => {
+      try {
+        return aAddon._sourceBundle.exists();
+      }
+      catch (e) {
+        if (e.result == Cr.NS_ERROR_NOT_INITIALIZED)
+          return false;
+        throw e;
+      }
+    };
+
+    // Get the previous add-ons from the database and put them into maps by location
+    let previousAddons = new Map();
+    for (let a of XPIDatabase.getAddons()) {
+      let locationAddonMap = previousAddons.get(a.location);
+      if (!locationAddonMap) {
+        locationAddonMap = new Map();
+        previousAddons.set(a.location, locationAddonMap);
+      }
+      locationAddonMap.set(a.id, a);
+    }
+
+    // Build the list of current add-ons into similar maps. When add-ons are still
+    // present we re-use the add-on objects from the database and update their
+    // details directly
+    let currentAddons = new Map();
+    for (let installLocation of XPIProvider.installLocations) {
+      let locationAddonMap = new Map();
+      currentAddons.set(installLocation.name, locationAddonMap);
+
+      // Get all the on-disk XPI states for this location, and keep track of which
+      // ones we see in the database.
+      let states = XPIStates.getLocation(installLocation.name);
+
+      // Iterate through the add-ons installed the last time the application
+      // ran
+      let dbAddons = previousAddons.get(installLocation.name);
+      if (dbAddons) {
+        for (let [id, oldAddon] of dbAddons) {
+          // Check if the add-on is still installed
+          let xpiState = states && states.get(id);
+          if (xpiState) {
+            // Here the add-on was present in the database and on disk
+            recordAddonTelemetry(oldAddon);
+
+            // Check if the add-on has been changed outside the XPI provider
+            if (oldAddon.updateDate != xpiState.mtime) {
+              // Did time change in the wrong direction?
+              if (xpiState.mtime < oldAddon.updateDate) {
+                XPIProvider.setTelemetry(oldAddon.id, "olderFile", {
+                  name: XPIProvider._mostRecentlyModifiedFile[id],
+                  mtime: xpiState.mtime,
+                  oldtime: oldAddon.updateDate
+                });
+              } else {
+                XPIProvider.setTelemetry(oldAddon.id, "modifiedFile",
+                                         XPIProvider._mostRecentlyModifiedFile[id]);
+              }
+            }
+
+            // The add-on has changed if the modification time has changed, if
+            // we have an updated manifest for it, or if the schema version has
+            // changed.
+            //
+            // Also reload the metadata for add-ons in the application directory
+            // when the application version has changed.
+            let newAddon = loadedManifest(installLocation, id);
+            if (newAddon || oldAddon.updateDate != xpiState.mtime ||
+                (aUpdateCompatibility && (installLocation.name == KEY_APP_GLOBAL ||
+                                          installLocation.name == KEY_APP_SYSTEM_DEFAULTS))) {
+              newAddon = this.updateMetadata(installLocation, oldAddon, xpiState, newAddon);
+            }
+            else if (oldAddon.descriptor != xpiState.descriptor) {
+              newAddon = this.updateDescriptor(installLocation, oldAddon, xpiState);
+            }
+            // Check compatility when the application version and/or schema
+            // version has changed. A schema change also reloads metadata from
+            // the manifests.
+            else if (aUpdateCompatibility || aSchemaChange) {
+              newAddon = this.updateCompatibility(installLocation, oldAddon, xpiState,
+                                                  aOldAppVersion, aOldPlatformVersion,
+                                                  aSchemaChange);
+            }
+            else {
+              // No change
+              newAddon = oldAddon;
+            }
+
+            if (newAddon)
+              locationAddonMap.set(newAddon.id, newAddon);
+          }
+          else {
+            // The add-on is in the DB, but not in xpiState (and thus not on disk).
+            this.removeMetadata(oldAddon);
+          }
+        }
+      }
+
+      // Any add-on in our current location that we haven't seen needs to
+      // be added to the database.
+      // Get the migration data for this install location so we can include that as
+      // we add, in case this is a database upgrade or rebuild.
+      let locMigrateData = {};
+      if (XPIDatabase.migrateData && installLocation.name in XPIDatabase.migrateData)
+        locMigrateData = XPIDatabase.migrateData[installLocation.name];
+
+      if (states) {
+        for (let [id, xpiState] of states) {
+          if (locationAddonMap.has(id))
+            continue;
+          let migrateData = id in locMigrateData ? locMigrateData[id] : null;
+          let newAddon = loadedManifest(installLocation, id);
+          let addon = this.addMetadata(installLocation, id, xpiState, newAddon,
+                                       aOldAppVersion, aOldPlatformVersion, migrateData);
+          if (addon)
+            locationAddonMap.set(addon.id, addon);
+        }
+      }
+    }
+
+    // previousAddons may contain locations where the database contains add-ons
+    // but the browser is no longer configured to use that location. The metadata
+    // for those add-ons must be removed from the database.
+    for (let [locationName, addons] of previousAddons) {
+      if (!currentAddons.has(locationName)) {
+        for (let [id, oldAddon] of addons)
+          this.removeMetadata(oldAddon);
+      }
+    }
+
+    // Validate the updated system add-ons
+    let systemAddonLocation = XPIProvider.installLocationsByName[KEY_APP_SYSTEM_ADDONS];
+    let addons = currentAddons.get(KEY_APP_SYSTEM_ADDONS) || new Map();
+
+    let hideLocation;
+
+    if (!systemAddonLocation.isValid(addons)) {
+      // Hide the system add-on updates if any are invalid.
+      logger.info("One or more updated system add-ons invalid, falling back to defaults.");
+      hideLocation = KEY_APP_SYSTEM_ADDONS;
+    }
+
+    let previousVisible = this.getVisibleAddons(previousAddons);
+    let currentVisible = this.flattenByID(currentAddons, hideLocation);
+    let sawActiveTheme = false;
+    XPIProvider.bootstrappedAddons = {};
+
+    // Pass over the new set of visible add-ons, record any changes that occured
+    // during startup and call bootstrap install/uninstall scripts as necessary
+    for (let [id, currentAddon] of currentVisible) {
+      let previousAddon = previousVisible.get(id);
+
+      // Note if any visible add-on is not in the application install location
+      if (currentAddon._installLocation.name != KEY_APP_GLOBAL)
+        XPIProvider.allAppGlobal = false;
+
+      let isActive = !currentAddon.disabled;
+      let wasActive = previousAddon ? previousAddon.active : currentAddon.active
+
+      if (!previousAddon) {
+        // If we had a manifest for this add-on it was a staged install and
+        // so wasn't something recovered from a corrupt database
+        let wasStaged = !!loadedManifest(currentAddon._installLocation, id);
+
+        // We might be recovering from a corrupt database, if so use the
+        // list of known active add-ons to update the new add-on
+        if (!wasStaged && XPIDatabase.activeBundles) {
+          // For themes we know which is active by the current skin setting
+          if (currentAddon.type == "theme")
+            isActive = currentAddon.internalName == XPIProvider.currentSkin;
+          else
+            isActive = XPIDatabase.activeBundles.indexOf(currentAddon.descriptor) != -1;
+
+          // If the add-on wasn't active and it isn't already disabled in some way
+          // then it was probably either softDisabled or userDisabled
+          if (!isActive && !currentAddon.disabled) {
+            // If the add-on is softblocked then assume it is softDisabled
+            if (currentAddon.blocklistState == Blocklist.STATE_SOFTBLOCKED)
+              currentAddon.softDisabled = true;
+            else
+              currentAddon.userDisabled = true;
+          }
+        }
+        else {
+          // This is a new install
+          if (currentAddon.foreignInstall)
+            AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED, id);
+
+          if (currentAddon.bootstrap) {
+            AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED, id);
+            // Visible bootstrapped add-ons need to have their install method called
+            XPIProvider.callBootstrapMethod(currentAddon, currentAddon._sourceBundle,
+                                            "install", BOOTSTRAP_REASONS.ADDON_INSTALL);
+            if (!isActive)
+              XPIProvider.unloadBootstrapScope(currentAddon.id);
+          }
+        }
+      }
+      else {
+        if (previousAddon !== currentAddon) {
+          // This is an add-on that has changed, either the metadata was reloaded
+          // or the version in a different location has become visible
+          AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED, id);
+
+          let installReason = Services.vc.compare(previousAddon.version, currentAddon.version) < 0 ?
+                              BOOTSTRAP_REASONS.ADDON_UPGRADE :
+                              BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
+
+          // If the previous add-on was in a different path, bootstrapped
+          // and still exists then call its uninstall method.
+          if (previousAddon.bootstrap && previousAddon._installLocation &&
+              exists(previousAddon) &&
+              currentAddon._sourceBundle.path != previousAddon._sourceBundle.path) {
+
+            XPIProvider.callBootstrapMethod(previousAddon, previousAddon._sourceBundle,
+                                            "uninstall", installReason,
+                                            { newVersion: currentAddon.version });
+            XPIProvider.unloadBootstrapScope(previousAddon.id);
+          }
+
+          // Make sure to flush the cache when an old add-on has gone away
+          flushChromeCaches();
+
+          if (currentAddon.bootstrap) {
+            // Visible bootstrapped add-ons need to have their install method called
+            let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+            file.persistentDescriptor = currentAddon._sourceBundle.persistentDescriptor;
+            XPIProvider.callBootstrapMethod(currentAddon, file,
+                                            "install", installReason,
+                                            { oldVersion: previousAddon.version });
+            if (currentAddon.disabled)
+              XPIProvider.unloadBootstrapScope(currentAddon.id);
+          }
+        }
+
+        if (isActive != wasActive) {
+          let change = isActive ? AddonManager.STARTUP_CHANGE_ENABLED
+                                : AddonManager.STARTUP_CHANGE_DISABLED;
+          AddonManagerPrivate.addStartupChange(change, id);
+        }
+      }
+
+      XPIDatabase.makeAddonVisible(currentAddon);
+      currentAddon.active = isActive;
+
+      // Make sure the bootstrap information is up to date for this ID
+      if (currentAddon.bootstrap && currentAddon.active) {
+        XPIProvider.bootstrappedAddons[id] = {
+          version: currentAddon.version,
+          type: currentAddon.type,
+          descriptor: currentAddon._sourceBundle.persistentDescriptor,
+          multiprocessCompatible: currentAddon.multiprocessCompatible,
+          runInSafeMode: canRunInSafeMode(currentAddon),
+          dependencies: currentAddon.dependencies,
+          hasEmbeddedWebExtension: currentAddon.hasEmbeddedWebExtension,
+        };
+      }
+
+      if (currentAddon.active && currentAddon.internalName == XPIProvider.selectedSkin)
+        sawActiveTheme = true;
+    }
+
+    // Pass over the set of previously visible add-ons that have now gone away
+    // and record the change.
+    for (let [id, previousAddon] of previousVisible) {
+      if (currentVisible.has(id))
+        continue;
+
+      // This add-on vanished
+
+      // If the previous add-on was bootstrapped and still exists then call its
+      // uninstall method.
+      if (previousAddon.bootstrap && exists(previousAddon)) {
+        XPIProvider.callBootstrapMethod(previousAddon, previousAddon._sourceBundle,
+                                        "uninstall", BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+        XPIProvider.unloadBootstrapScope(previousAddon.id);
+      }
+      AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_UNINSTALLED, id);
+
+      // Make sure to flush the cache when an old add-on has gone away
+      flushChromeCaches();
+    }
+
+    // Make sure add-ons from hidden locations are marked invisible and inactive
+    let locationAddonMap = currentAddons.get(hideLocation);
+    if (locationAddonMap) {
+      for (let addon of locationAddonMap.values()) {
+        addon.visible = false;
+        addon.active = false;
+      }
+    }
+
+    // If a custom theme is selected and it wasn't seen in the new list of
+    // active add-ons then enable the default theme
+    if (XPIProvider.selectedSkin != XPIProvider.defaultSkin && !sawActiveTheme) {
+      logger.info("Didn't see selected skin " + XPIProvider.selectedSkin);
+      XPIProvider.enableDefaultTheme();
+    }
+
+    // Finally update XPIStates to match everything
+    for (let [locationName, locationAddonMap] of currentAddons) {
+      for (let [id, addon] of locationAddonMap) {
+        let xpiState = XPIStates.getAddon(locationName, id);
+        xpiState.syncWithDB(addon);
+      }
+    }
+    XPIStates.save();
+
+    XPIProvider.persistBootstrappedAddons();
+
+    // Clear out any cached migration data.
+    XPIDatabase.migrateData = null;
+    XPIDatabase.saveChanges();
+
+    return true;
+  },
+}
diff --git a/toolkit/mozapps/webextensions/internal/moz.build b/toolkit/mozapps/webextensions/internal/moz.build
new file mode 100644
index 000000000..28c34f8c9
--- /dev/null
+++ b/toolkit/mozapps/webextensions/internal/moz.build
@@ -0,0 +1,36 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXTRA_JS_MODULES.addons += [
+    'AddonLogging.jsm',
+    'AddonRepository.jsm',
+    'AddonRepository_SQLiteMigrator.jsm',
+    'AddonUpdateChecker.jsm',
+    'APIExtensionBootstrap.js',
+    'Content.js',
+    'E10SAddonsRollout.jsm',
+    'GMPProvider.jsm',
+    'LightweightThemeImageOptimizer.jsm',
+    'ProductAddonChecker.jsm',
+    'SpellCheckDictionaryBootstrap.js',
+    'WebExtensionBootstrap.js',
+    'XPIProvider.jsm',
+    'XPIProviderUtils.js',
+]
+
+TESTING_JS_MODULES += [
+    'AddonTestUtils.jsm',
+]
+
+# Don't ship unused providers on Android
+if CONFIG['MOZ_WIDGET_TOOLKIT'] != 'android':
+    EXTRA_JS_MODULES.addons += [
+        'PluginProvider.jsm',
+    ]
+
+EXTRA_PP_JS_MODULES.addons += [
+    'AddonConstants.jsm',
+]