Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4836 insertions, 0 deletions

diff --git a/toolkit/mozapps/extensions/internal/XPIInstall.jsm b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
new file mode 100644
index 0000000000..e13c2fc567
--- /dev/null
+++ b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
@@ -0,0 +1,4836 @@
+/* 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 file contains most of the logic required to install extensions.
+ * In general, we try to avoid loading it until extension installation
+ * or update is required. Please keep that in mind when deciding whether
+ * to add code here or elsewhere.
+ */
+
+/**
+ * @typedef {number} integer
+ */
+
+/* eslint "valid-jsdoc": [2, {requireReturn: false, requireReturnDescription: false, prefer: {return: "returns"}}] */
+
+var EXPORTED_SYMBOLS = [
+  "UpdateChecker",
+  "XPIInstall",
+  "verifyBundleSignedState",
+];
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+const {
+  computeSha256HashAsString,
+  getHashStringForCrypto,
+} = ChromeUtils.importESModule(
+  "resource://gre/modules/addons/crypto-utils.sys.mjs"
+);
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { AddonManager, AddonManagerPrivate } = ChromeUtils.import(
+  "resource://gre/modules/AddonManager.jsm"
+);
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  CertUtils: "resource://gre/modules/CertUtils.sys.mjs",
+  FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+  UpdateUtils: "resource://gre/modules/UpdateUtils.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  AddonRepository: "resource://gre/modules/addons/AddonRepository.jsm",
+  AddonSettings: "resource://gre/modules/addons/AddonSettings.jsm",
+  BuiltInThemesHelpers: "resource://gre/modules/addons/XPIDatabase.jsm",
+  ExtensionData: "resource://gre/modules/Extension.jsm",
+  NetUtil: "resource://gre/modules/NetUtil.jsm",
+  ProductAddonChecker: "resource://gre/modules/addons/ProductAddonChecker.jsm",
+  AddonInternal: "resource://gre/modules/addons/XPIDatabase.jsm",
+  XPIDatabase: "resource://gre/modules/addons/XPIDatabase.jsm",
+  XPIInternal: "resource://gre/modules/addons/XPIProvider.jsm",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "IconDetails", () => {
+  return ChromeUtils.import("resource://gre/modules/ExtensionParent.jsm")
+    .ExtensionParent.IconDetails;
+});
+
+const { nsIBlocklistService } = Ci;
+
+const nsIFile = Components.Constructor(
+  "@mozilla.org/file/local;1",
+  "nsIFile",
+  "initWithPath"
+);
+
+const BinaryOutputStream = Components.Constructor(
+  "@mozilla.org/binaryoutputstream;1",
+  "nsIBinaryOutputStream",
+  "setOutputStream"
+);
+const CryptoHash = Components.Constructor(
+  "@mozilla.org/security/hash;1",
+  "nsICryptoHash",
+  "initWithString"
+);
+const FileInputStream = Components.Constructor(
+  "@mozilla.org/network/file-input-stream;1",
+  "nsIFileInputStream",
+  "init"
+);
+const FileOutputStream = Components.Constructor(
+  "@mozilla.org/network/file-output-stream;1",
+  "nsIFileOutputStream",
+  "init"
+);
+const ZipReader = Components.Constructor(
+  "@mozilla.org/libjar/zip-reader;1",
+  "nsIZipReader",
+  "open"
+);
+
+XPCOMUtils.defineLazyServiceGetters(lazy, {
+  gCertDB: ["@mozilla.org/security/x509certdb;1", "nsIX509CertDB"],
+});
+
+const PREF_INSTALL_REQUIRESECUREORIGIN =
+  "extensions.install.requireSecureOrigin";
+const PREF_PENDING_OPERATIONS = "extensions.pendingOperations";
+const PREF_SYSTEM_ADDON_UPDATE_URL = "extensions.systemAddon.update.url";
+const PREF_XPI_ENABLED = "xpinstall.enabled";
+const PREF_XPI_DIRECT_WHITELISTED = "xpinstall.whitelist.directRequest";
+const PREF_XPI_FILE_WHITELISTED = "xpinstall.whitelist.fileRequest";
+const PREF_XPI_WHITELIST_REQUIRED = "xpinstall.whitelist.required";
+
+const PREF_SELECTED_THEME = "extensions.activeThemeID";
+
+const TOOLKIT_ID = "toolkit@mozilla.org";
+
+/**
+ * Returns a nsIFile instance for the given path, relative to the given
+ * base file, if provided.
+ *
+ * @param {string} path
+ *        The (possibly relative) path of the file.
+ * @param {nsIFile} [base]
+ *        An optional file to use as a base path if `path` is relative.
+ * @returns {nsIFile}
+ */
+function getFile(path, base = null) {
+  // First try for an absolute path, as we get in the case of proxy
+  // files. Ideally we would try a relative path first, but on Windows,
+  // paths which begin with a drive letter are valid as relative paths,
+  // and treated as such.
+  try {
+    return new nsIFile(path);
+  } catch (e) {
+    // Ignore invalid relative paths. The only other error we should see
+    // here is EOM, and either way, any errors that we care about should
+    // be re-thrown below.
+  }
+
+  // If the path isn't absolute, we must have a base path.
+  let file = base.clone();
+  file.appendRelativePath(path);
+  return file;
+}
+
+/**
+ * Sends local and remote notifications to flush a JAR file cache entry
+ *
+ * @param {nsIFile} aJarFile
+ *        The ZIP/XPI/JAR file as a nsIFile
+ */
+function flushJarCache(aJarFile) {
+  Services.obs.notifyObservers(aJarFile, "flush-cache-entry");
+  Services.ppmm.broadcastAsyncMessage(MSG_JAR_FLUSH, {
+    path: aJarFile.path,
+  });
+}
+
+const PREF_EM_UPDATE_BACKGROUND_URL = "extensions.update.background.url";
+const PREF_EM_UPDATE_URL = "extensions.update.url";
+const PREF_XPI_SIGNATURES_DEV_ROOT = "xpinstall.signatures.dev-root";
+
+const KEY_TEMPDIR = "TmpD";
+
+// 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
+);
+
+const MSG_JAR_FLUSH = "Extension:FlushJarCache";
+
+/**
+ * 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;
+
+const { Log } = ChromeUtils.importESModule(
+  "resource://gre/modules/Log.sys.mjs"
+);
+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);
+
+// Stores the ID of the theme which was selected during the last session,
+// if any. When installing a new built-in theme with this ID, it will be
+// automatically enabled.
+let lastSelectedTheme = null;
+
+function getJarURI(file, path = "") {
+  if (file instanceof Ci.nsIFile) {
+    file = Services.io.newFileURI(file);
+  }
+  if (file instanceof Ci.nsIURI) {
+    file = file.spec;
+  }
+  return Services.io.newURI(`jar:${file}!/${path}`);
+}
+
+let DirPackage;
+let XPIPackage;
+class Package {
+  static get(file) {
+    if (file.isFile()) {
+      return new XPIPackage(file);
+    }
+    return new DirPackage(file);
+  }
+
+  constructor(file, rootURI) {
+    this.file = file;
+    this.filePath = file.path;
+    this.rootURI = rootURI;
+  }
+
+  close() {}
+
+  async readString(...path) {
+    let buffer = await this.readBinary(...path);
+    return new TextDecoder().decode(buffer);
+  }
+
+  async verifySignedState(addonId, addonType, addonLocation) {
+    if (!shouldVerifySignedState(addonType, addonLocation)) {
+      return {
+        signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED,
+        cert: null,
+      };
+    }
+
+    let root = Ci.nsIX509CertDB.AddonsPublicRoot;
+    if (
+      !AppConstants.MOZ_REQUIRE_SIGNING &&
+      Services.prefs.getBoolPref(PREF_XPI_SIGNATURES_DEV_ROOT, false)
+    ) {
+      root = Ci.nsIX509CertDB.AddonsStageRoot;
+    }
+
+    return this.verifySignedStateForRoot(addonId, root);
+  }
+
+  flushCache() {}
+}
+
+DirPackage = class DirPackage extends Package {
+  constructor(file) {
+    super(file, Services.io.newFileURI(file));
+  }
+
+  hasResource(...path) {
+    return IOUtils.exists(PathUtils.join(this.filePath, ...path));
+  }
+
+  async iterDirectory(path, callback) {
+    let fullPath = PathUtils.join(this.filePath, ...path);
+
+    let children = await IOUtils.getChildren(fullPath);
+    for (let path of children) {
+      let { type } = await IOUtils.stat(path);
+      callback({
+        isDir: type == "directory",
+        name: PathUtils.filename(path),
+        path,
+      });
+    }
+  }
+
+  iterFiles(callback, path = []) {
+    return this.iterDirectory(path, async entry => {
+      let entryPath = [...path, entry.name];
+      if (entry.isDir) {
+        callback({
+          path: entryPath.join("/"),
+          isDir: true,
+        });
+        await this.iterFiles(callback, entryPath);
+      } else {
+        callback({
+          path: entryPath.join("/"),
+          isDir: false,
+        });
+      }
+    });
+  }
+
+  readBinary(...path) {
+    return IOUtils.read(PathUtils.join(this.filePath, ...path));
+  }
+
+  async verifySignedStateForRoot(addonId, root) {
+    return { signedState: AddonManager.SIGNEDSTATE_UNKNOWN, cert: null };
+  }
+};
+
+XPIPackage = class XPIPackage extends Package {
+  constructor(file) {
+    super(file, getJarURI(file));
+
+    this.zipReader = new ZipReader(file);
+  }
+
+  close() {
+    this.zipReader.close();
+    this.zipReader = null;
+    this.flushCache();
+  }
+
+  async hasResource(...path) {
+    return this.zipReader.hasEntry(path.join("/"));
+  }
+
+  async iterFiles(callback) {
+    for (let path of this.zipReader.findEntries("*")) {
+      let entry = this.zipReader.getEntry(path);
+      callback({
+        path,
+        isDir: entry.isDirectory,
+      });
+    }
+  }
+
+  async readBinary(...path) {
+    let response = await fetch(this.rootURI.resolve(path.join("/")));
+    return response.arrayBuffer();
+  }
+
+  verifySignedStateForRoot(addonId, root) {
+    return new Promise(resolve => {
+      let callback = {
+        openSignedAppFileFinished(aRv, aZipReader, aCert) {
+          if (aZipReader) {
+            aZipReader.close();
+          }
+          resolve({
+            signedState: getSignedStatus(aRv, aCert, addonId),
+            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;
+
+      lazy.gCertDB.openSignedAppFileAsync(root, this.file, callback);
+    });
+  }
+
+  flushCache() {
+    flushJarCache(this.file);
+  }
+};
+
+/**
+ * Return an object that implements enough of the Package interface
+ * to allow loadManifest() to work for a built-in addon (ie, one loaded
+ * from a resource: url)
+ *
+ * @param {nsIURL} baseURL The URL for the root of the add-on.
+ * @returns {object}
+ */
+function builtinPackage(baseURL) {
+  return {
+    rootURI: baseURL,
+    filePath: baseURL.spec,
+    file: null,
+    verifySignedState() {
+      return {
+        signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED,
+        cert: null,
+      };
+    },
+    async hasResource(path) {
+      try {
+        let response = await fetch(this.rootURI.resolve(path));
+        return response.ok;
+      } catch (e) {
+        return false;
+      }
+    },
+  };
+}
+
+/**
+ * Determine the reason to pass to an extension's bootstrap methods when
+ * switch between versions.
+ *
+ * @param {string} oldVersion The version of the existing extension instance.
+ * @param {string} newVersion The version of the extension being installed.
+ *
+ * @returns {integer}
+ *        BOOSTRAP_REASONS.ADDON_UPGRADE or BOOSTRAP_REASONS.ADDON_DOWNGRADE
+ */
+function newVersionReason(oldVersion, newVersion) {
+  return Services.vc.compare(oldVersion, newVersion) <= 0
+    ? lazy.XPIInternal.BOOTSTRAP_REASONS.ADDON_UPGRADE
+    : lazy.XPIInternal.BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
+}
+
+// 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)
+    );
+  });
+}
+
+/**
+ * Reads an AddonInternal object from a webextension manifest.json
+ *
+ * @param {Package} aPackage
+ *        The install package for the add-on
+ * @param {XPIStateLocation} aLocation
+ *        The install location the add-on is installed in, or will be
+ *        installed to.
+ * @returns {{ addon: AddonInternal, verifiedSignedState: object}}
+ * @throws if the install manifest in the stream is corrupt or could not
+ *         be read
+ */
+async function loadManifestFromWebManifest(aPackage, aLocation) {
+  let verifiedSignedState;
+  const temporarilyInstalled = aLocation.isTemporary;
+  let extension = await lazy.ExtensionData.constructAsync({
+    rootURI: lazy.XPIInternal.maybeResolveURI(aPackage.rootURI),
+    temporarilyInstalled,
+    async checkPrivileged(type, id) {
+      verifiedSignedState = await aPackage.verifySignedState(
+        id,
+        type,
+        aLocation
+      );
+      return lazy.ExtensionData.getIsPrivileged({
+        signedState: verifiedSignedState.signedState,
+        builtIn: aLocation.isBuiltin,
+        temporarilyInstalled,
+      });
+    },
+  });
+
+  let manifest = await extension.loadManifest();
+
+  // Read the list of available locales, and pre-load messages for
+  // all locales.
+  let locales = !extension.errors.length
+    ? await extension.initAllLocales()
+    : null;
+
+  if (extension.errors.length) {
+    let error = new Error("Extension is invalid");
+    // Add detailed errors on the error object so that the front end can display them
+    // if needed (eg in about:debugging).
+    error.additionalErrors = extension.errors;
+    throw error;
+  }
+
+  // Internally, we use the `applications` key but it is because we assign the value
+  // of `browser_specific_settings` to `applications` in `ExtensionData.parseManifest()`.
+  // Yet, as of MV3, only `browser_specific_settings` is accepted in manifest.json files.
+  let bss = manifest.applications?.gecko || {};
+
+  // A * is illegal in strict_min_version
+  if (bss.strict_min_version?.split(".").some(part => part == "*")) {
+    throw new Error("The use of '*' in strict_min_version is invalid");
+  }
+
+  let addon = new lazy.AddonInternal();
+  addon.id = bss.id;
+  addon.version = manifest.version;
+  addon.manifestVersion = manifest.manifest_version;
+  addon.type = extension.type;
+  addon.loader = null;
+  addon.strictCompatibility = true;
+  addon.internalName = null;
+  addon.updateURL = bss.update_url;
+  addon.installOrigins = manifest.install_origins;
+  addon.optionsBrowserStyle = true;
+  addon.optionsURL = null;
+  addon.optionsType = null;
+  addon.aboutURL = null;
+  addon.dependencies = Object.freeze(Array.from(extension.dependencies));
+  addon.startupData = extension.startupData;
+  addon.hidden = extension.isPrivileged && manifest.hidden;
+  addon.incognito = manifest.incognito;
+
+  if (addon.type === "theme" && (await aPackage.hasResource("preview.png"))) {
+    addon.previewImage = "preview.png";
+  }
+
+  // TODO(Bug 1789718): Remove after the deprecated XPIProvider-based implementation is also removed.
+  if (addon.type == "sitepermission-deprecated") {
+    addon.sitePermissions = manifest.site_permissions;
+    addon.siteOrigin = manifest.install_origins[0];
+  }
+
+  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;
+    }
+
+    addon.optionsBrowserStyle = manifest.options_ui.browser_style;
+  }
+
+  // WebExtensions don't use iconURLs
+  addon.iconURL = null;
+  addon.icons = manifest.icons || {};
+  addon.userPermissions = extension.manifestPermissions;
+  addon.optionalPermissions = extension.manifestOptionalPermissions;
+  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 = [];
+  // Themes are disabled by default, except when they're installed from a web page.
+  addon.userDisabled = extension.type === "theme";
+  addon.softDisabled =
+    addon.blocklistState == nsIBlocklistService.STATE_SOFTBLOCKED;
+
+  return { addon, verifiedSignedState };
+}
+
+async function readRecommendationStates(aPackage, aAddonID) {
+  let recommendationData;
+  try {
+    recommendationData = await aPackage.readString(
+      "mozilla-recommendation.json"
+    );
+  } catch (e) {
+    // Ignore I/O errors.
+    return null;
+  }
+
+  try {
+    recommendationData = JSON.parse(recommendationData);
+  } catch (e) {
+    logger.warn("Failed to parse recommendation", e);
+  }
+
+  if (recommendationData) {
+    let { addon_id, states, validity } = recommendationData;
+
+    if (addon_id === aAddonID && Array.isArray(states) && validity) {
+      let validNotAfter = Date.parse(validity.not_after);
+      let validNotBefore = Date.parse(validity.not_before);
+      if (validNotAfter && validNotBefore) {
+        return {
+          validNotAfter,
+          validNotBefore,
+          states,
+        };
+      }
+    }
+    logger.warn(
+      `Invalid recommendation for ${aAddonID}: ${JSON.stringify(
+        recommendationData
+      )}`
+    );
+  }
+
+  return null;
+}
+
+function defineSyncGUID(aAddon) {
+  // Define .syncGUID as a lazy property which is also settable
+  Object.defineProperty(aAddon, "syncGUID", {
+    get: () => {
+      aAddon.syncGUID = Services.uuid.generateUUID().toString();
+      return aAddon.syncGUID;
+    },
+    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 = CryptoHash("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)}${
+    lazy.XPIInternal.TEMPORARY_ADDON_SUFFIX
+  }`;
+  logger.info(`Generated temp id ${id} (${sess.join("")}) for ${aFile.path}`);
+  return id;
+}
+
+var loadManifest = async function(aPackage, aLocation, aOldAddon) {
+  let addon;
+  let verifiedSignedState;
+  if (await aPackage.hasResource("manifest.json")) {
+    ({ addon, verifiedSignedState } = await loadManifestFromWebManifest(
+      aPackage,
+      aLocation
+    ));
+  } else {
+    // TODO bug 1674799: Remove this unused branch.
+    for (let loader of AddonManagerPrivate.externalExtensionLoaders.values()) {
+      if (await aPackage.hasResource(loader.manifestFile)) {
+        addon = await loader.loadManifest(aPackage);
+        addon.loader = loader.name;
+        verifiedSignedState = await aPackage.verifySignedState(
+          addon.id,
+          addon.type,
+          aLocation
+        );
+        break;
+      }
+    }
+  }
+
+  if (!addon) {
+    throw new Error(
+      `File ${aPackage.filePath} does not contain a valid manifest`
+    );
+  }
+
+  addon._sourceBundle = aPackage.file;
+  addon.rootURI = aPackage.rootURI.spec;
+  addon.location = aLocation;
+
+  let { signedState, cert } = verifiedSignedState;
+  addon.signedState = signedState;
+  addon.signedDate = cert?.validity?.notBefore / 1000 || null;
+
+  if (!addon.id) {
+    if (cert) {
+      addon.id = cert.commonName;
+      if (!gIDTest.test(addon.id)) {
+        throw new Error(`Extension is signed with an invalid id (${addon.id})`);
+      }
+    }
+    if (!addon.id && aLocation.isTemporary) {
+      addon.id = generateTemporaryInstallID(aPackage.file);
+    }
+  }
+
+  addon.propagateDisabledState(aOldAddon);
+  if (!aLocation.isSystem && !aLocation.isBuiltin) {
+    if (addon.type === "extension" && !aLocation.isTemporary) {
+      addon.recommendationState = await readRecommendationStates(
+        aPackage,
+        addon.id
+      );
+    }
+
+    await addon.updateBlocklistState();
+    addon.appDisabled = !lazy.XPIDatabase.isUsableAddon(addon);
+
+    // Always report when there is an attempt to install a blocked add-on.
+    // (transitions from STATE_BLOCKED to STATE_NOT_BLOCKED are checked
+    //  in the individual AddonInstall subclasses).
+    if (addon.blocklistState == nsIBlocklistService.STATE_BLOCKED) {
+      addon.recordAddonBlockChangeTelemetry(
+        aOldAddon ? "addon_update" : "addon_install"
+      );
+    }
+  }
+
+  defineSyncGUID(addon);
+
+  return addon;
+};
+
+/**
+ * Loads an add-on's manifest from the given file or directory.
+ *
+ * @param {nsIFile} aFile
+ *        The file to load the manifest from.
+ * @param {XPIStateLocation} aLocation
+ *        The install location the add-on is installed in, or will be
+ *        installed to.
+ * @param {AddonInternal?} aOldAddon
+ *        The currently-installed add-on with the same ID, if one exist.
+ *        This is used to migrate user settings like the add-on's
+ *        disabled state.
+ * @returns {AddonInternal}
+ *        The parsed Addon object for the file's manifest.
+ */
+var loadManifestFromFile = async function(aFile, aLocation, aOldAddon) {
+  let pkg = Package.get(aFile);
+  try {
+    let addon = await loadManifest(pkg, aLocation, aOldAddon);
+    return addon;
+  } finally {
+    pkg.close();
+  }
+};
+
+/*
+ * A synchronous method for loading an add-on's manifest. Do not use
+ * this.
+ */
+function syncLoadManifest(state, location, oldAddon) {
+  if (location.name == "app-builtin") {
+    let pkg = builtinPackage(Services.io.newURI(state.rootURI));
+    return lazy.XPIInternal.awaitPromise(loadManifest(pkg, location, oldAddon));
+  }
+
+  let file = new nsIFile(state.path);
+  let pkg = Package.get(file);
+  return lazy.XPIInternal.awaitPromise(
+    (async () => {
+      try {
+        let addon = await loadManifest(pkg, location, oldAddon);
+        addon.rootURI = lazy.XPIInternal.getURIForResourceInFile(file, "").spec;
+        return addon;
+      } finally {
+        pkg.close();
+      }
+    })()
+  );
+}
+
+/**
+ * Creates and returns a new unique temporary file. The caller should delete
+ * the file when it is no longer needed.
+ *
+ * @returns {nsIFile}
+ *       An nsIFile that points to a randomly named, initially empty file in
+ *       the OS temporary files directory
+ */
+function getTemporaryFile() {
+  let file = lazy.FileUtils.getDir(KEY_TEMPDIR, []);
+  let random = Math.round(Math.random() * 36 ** 3).toString(36);
+  file.append(`tmp-${random}.xpi`);
+  file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, lazy.FileUtils.PERMS_FILE);
+  return file;
+}
+
+function getHashForFile(file, algorithm) {
+  let crypto = CryptoHash(algorithm);
+  let fis = new FileInputStream(file, -1, -1, false);
+  try {
+    crypto.updateFromStream(fis, file.fileSize);
+  } finally {
+    fis.close();
+  }
+  return getHashStringForCrypto(crypto);
+}
+
+/**
+ * Returns the signedState for a given return code and certificate by verifying
+ * it against the expected ID.
+ *
+ * @param {nsresult} aRv
+ *        The result code returned by the signature checker for the
+ *        signature check operation.
+ * @param {nsIX509Cert?} aCert
+ *        The certificate the add-on was signed with, if a valid
+ *        certificate exists.
+ * @param {string?} aAddonID
+ *        The expected ID of the add-on. If passed, this must match the
+ *        ID in the certificate's CN field.
+ * @returns {number}
+ *        A SIGNEDSTATE result code constant, as defined on the
+ *        AddonManager class.
+ */
+function getSignedStatus(aRv, aCert, aAddonID) {
+  let expectedCommonName = aAddonID;
+  if (aAddonID && aAddonID.length > 64) {
+    expectedCommonName = computeSha256HashAsString(aAddonID);
+  }
+
+  switch (aRv) {
+    case Cr.NS_OK:
+      if (expectedCommonName && expectedCommonName != aCert.commonName) {
+        return AddonManager.SIGNEDSTATE_BROKEN;
+      }
+
+      if (aCert.organizationalUnit == "Mozilla Components") {
+        return AddonManager.SIGNEDSTATE_SYSTEM;
+      }
+
+      if (aCert.organizationalUnit == "Mozilla Extensions") {
+        return AddonManager.SIGNEDSTATE_PRIVILEGED;
+      }
+
+      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(aAddonType, aLocation) {
+  // TODO when KEY_APP_SYSTEM_DEFAULTS and KEY_APP_SYSTEM_ADDONS locations
+  // are removed, we need to reorganize the logic here.  At that point we
+  // should:
+  //   if builtin or MOZ_UNSIGNED_SCOPES return false
+  //   if system return true
+  //   return SIGNED_TYPES.has(type)
+
+  // We don't care about signatures for default system add-ons
+  if (aLocation.name == lazy.XPIInternal.KEY_APP_SYSTEM_DEFAULTS) {
+    return false;
+  }
+
+  // Updated system add-ons should always have their signature checked
+  if (aLocation.isSystem) {
+    return true;
+  }
+
+  if (
+    aLocation.isBuiltin ||
+    aLocation.scope & AppConstants.MOZ_UNSIGNED_SCOPES
+  ) {
+    return false;
+  }
+
+  // Otherwise only check signatures if the add-on is one of the signed
+  // types.
+  return lazy.XPIDatabase.SIGNED_TYPES.has(aAddonType);
+}
+
+/**
+ * Verifies that a bundle's contents are all correctly signed by an
+ * AMO-issued certificate
+ *
+ * @param {nsIFile} aBundle
+ *        The nsIFile for the bundle to check, either a directory or zip file.
+ * @param {AddonInternal} aAddon
+ *        The add-on object to verify.
+ * @returns {Promise<number>}
+ *        A Promise that resolves to an AddonManager.SIGNEDSTATE_* constant.
+ */
+var verifyBundleSignedState = async function(aBundle, aAddon) {
+  let pkg = Package.get(aBundle);
+  try {
+    let { signedState } = await pkg.verifySignedState(
+      aAddon.id,
+      aAddon.type,
+      aAddon.location
+    );
+    return signedState;
+  } finally {
+    pkg.close();
+  }
+};
+
+/**
+ * Replaces %...% strings in an addon url (update and updateInfo) with
+ * appropriate values.
+ *
+ * @param {AddonInternal} aAddon
+ *        The AddonInternal representing the add-on
+ * @param {string} aUri
+ *        The URI to escape
+ * @param {integer?} aUpdateType
+ *        An optional number representing the type of update, only applicable
+ *        when creating a url for retrieving an update manifest
+ * @param {string?} aAppVersion
+ *        The optional application version to use for %APP_VERSION%
+ * @returns {string}
+ *       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;
+}
+
+/**
+ * Converts an iterable of addon objects into a map with the add-on's ID as key.
+ *
+ * @param {sequence<AddonInternal>} addons
+ *        A sequence of AddonInternal objects.
+ *
+ * @returns {Map<string, AddonInternal>}
+ */
+function addonMap(addons) {
+  return new Map(addons.map(a => [a.id, a]));
+}
+
+async function removeAsync(aFile) {
+  await IOUtils.remove(aFile.path, { ignoreAbsent: true, recursive: true });
+}
+
+/**
+ * Recursively removes a directory or file fixing permissions when necessary.
+ *
+ * @param {nsIFile} 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_NOT_FOUND) {
+      return;
+    }
+
+    throw e;
+  }
+
+  setFilePermissions(
+    aFile,
+    isDir ? lazy.FileUtils.PERMS_DIRECTORY : lazy.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 = Array.from(lazy.XPIInternal.iterDirectory(aFile));
+  entries.forEach(recursiveRemove);
+
+  try {
+    aFile.remove(true);
+  } catch (e) {
+    logger.error("Failed to remove empty directory " + aFile.path, e);
+    throw e;
+  }
+}
+
+/**
+ * Sets permissions on a file
+ *
+ * @param {nsIFile} aFile
+ *        The file or directory to operate on.
+ * @param {integer} aPermissions
+ *        The permissions 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 {nsIFile} file
+ *        The nsIFile instance to write into
+ * @param {string} string
+ *        The string to write
+ */
+function writeStringToFile(file, string) {
+  let fileStream = new FileOutputStream(
+    file,
+    lazy.FileUtils.MODE_WRONLY |
+      lazy.FileUtils.MODE_CREATE |
+      lazy.FileUtils.MODE_TRUNCATE,
+    lazy.FileUtils.PERMS_FILE,
+    0
+  );
+
+  try {
+    let binStream = new BinaryOutputStream(fileStream);
+
+    binStream.writeByteArray(new TextEncoder().encode(string));
+  } finally {
+    fileStream.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(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 = getFile(aFile.leafName, aTargetDirectory);
+        // 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, newFile });
+  },
+
+  /**
+   * 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 {nsIFile} aFile
+   *        The file or directory to be moved.
+   * @param {nsIFile} aTargetDirectory
+   *        The directory to move into, this is expected to be an empty
+   *        directory.
+   */
+  moveUnder(aFile, aTargetDirectory) {
+    try {
+      this._installFile(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 {nsIFile} aOldLocation
+   *        The old location of the file.
+   * @param {nsIFile} aNewLocation
+   *        The new location of the file.
+   */
+  moveTo(aOldLocation, aNewLocation) {
+    try {
+      let oldFile = aOldLocation.clone(),
+        newFile = aNewLocation.clone();
+      oldFile.moveTo(newFile.parent, newFile.leafName);
+      this._installedFiles.push({ oldFile, 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 {nsIFile} aFile
+   *        The file or directory to be copied.
+   * @param {nsIFile} aTargetDirectory
+   *        The directory to copy into, this is expected to be an empty
+   *        directory.
+   */
+  copy(aFile, aTargetDirectory) {
+    try {
+      this._installFile(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() {
+    while (this._installedFiles.length) {
+      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 = getFile(move.oldFile.leafName, move.oldFile.parent);
+        oldDir.create(
+          Ci.nsIFile.DIRECTORY_TYPE,
+          lazy.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) {
+      recursiveRemove(this._createdDirs.pop());
+    }
+  },
+};
+
+// A hash algorithm if the caller of AddonInstall did not specify one.
+const DEFAULT_HASH_ALGO = "sha256";
+
+/**
+ * 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 {XPIStateLocation} installLocation
+   *        The install location the add-on will be installed into
+   * @param {nsIURL} url
+   *        The nsIURL to get the add-on from. If this is an nsIFileURL then
+   *        the add-on will not need to be downloaded
+   * @param {Object} [options = {}]
+   *        Additional options for the install
+   * @param {string} [options.hash]
+   *        An optional hash for the add-on
+   * @param {AddonInternal} [options.existingAddon]
+   *        The add-on this install will update if known
+   * @param {string} [options.name]
+   *        An optional name for the add-on
+   * @param {string} [options.type]
+   *        An optional type for the add-on
+   * @param {object} [options.icons]
+   *        Optional icons for the add-on
+   * @param {string} [options.version]
+   *        The expected version for the add-on.
+   *        Required for updates, i.e. when existingAddon is set.
+   * @param {Object?} [options.telemetryInfo]
+   *        An optional object which provides details about the installation source
+   *        included in the addon manager telemetry events.
+   * @param {boolean} [options.isUserRequestedUpdate]
+   *        An optional boolean, true if the install object is related to a user triggered update.
+   * @param {nsIURL} [options.releaseNotesURI]
+   *        An optional nsIURL that release notes where release notes can be retrieved.
+   * @param {function(string) : Promise<void>} [options.promptHandler]
+   *        A callback to prompt the user before installing.
+   */
+  constructor(installLocation, url, options = {}) {
+    this.wrapper = new AddonInstallWrapper(this);
+    this.location = installLocation;
+    this.sourceURI = url;
+
+    if (options.hash) {
+      let hashSplit = options.hash.toLowerCase().split(":");
+      this.originalHash = {
+        algorithm: hashSplit[0],
+        data: hashSplit[1],
+      };
+    }
+    this.hash = this.originalHash;
+    this.fileHash = null;
+    this.existingAddon = options.existingAddon || null;
+    this.promptHandler = options.promptHandler || (() => Promise.resolve());
+    this.releaseNotesURI = options.releaseNotesURI || null;
+
+    this._startupPromise = null;
+
+    this._installPromise = new Promise(resolve => {
+      this._resolveInstallPromise = resolve;
+    });
+    // Ignore uncaught rejections for this promise, since they're
+    // handled by install listeners.
+    this._installPromise.catch(() => {});
+
+    this.listeners = [];
+    this.icons = options.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 = options.name || null;
+    this.type = options.type || null;
+    this.version = options.version || null;
+    this.isUserRequestedUpdate = options.isUserRequestedUpdate;
+    this.installTelemetryInfo = null;
+
+    if (options.telemetryInfo) {
+      this.installTelemetryInfo = options.telemetryInfo;
+    } else if (this.existingAddon) {
+      // Inherits the installTelemetryInfo on updates (so that the source of the original
+      // installation telemetry data is being preserved across the extension updates).
+      this.installTelemetryInfo = this.existingAddon.installTelemetryInfo;
+      this.existingAddon._updateInstall = this;
+    }
+
+    this.file = null;
+    this.ownsTempFile = null;
+
+    this.addon = null;
+    this.state = null;
+
+    XPIInstall.installs.add(this);
+  }
+
+  /**
+   * Called when we are finished with this install and are ready to remove
+   * any external references to it.
+   */
+  _cleanup() {
+    XPIInstall.installs.delete(this);
+    if (this.addon && this.addon._install) {
+      if (this.addon._install === this) {
+        this.addon._install = null;
+      } else {
+        Cu.reportError(new Error("AddonInstall mismatch"));
+      }
+    }
+    if (this.existingAddon && this.existingAddon._updateInstall) {
+      if (this.existingAddon._updateInstall === this) {
+        this.existingAddon._updateInstall = null;
+      } else {
+        Cu.reportError(new Error("AddonInstall existingAddon mismatch"));
+      }
+    }
+  }
+
+  /**
+   * 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.
+   *
+   * @returns {Promise<Addon>}
+   * @throws if installation cannot proceed from the current state
+   */
+  install() {
+    switch (this.state) {
+      case AddonManager.STATE_DOWNLOADED:
+        this.checkPrompt();
+        break;
+      case AddonManager.STATE_PROMPTS_DONE:
+        this.checkForBlockers();
+        break;
+      case AddonManager.STATE_READY:
+        this.startInstall();
+        break;
+      case AddonManager.STATE_POSTPONED:
+        logger.debug(`Postponing install of ${this.addon.id}`);
+        break;
+      case AddonManager.STATE_DOWNLOADING:
+      case AddonManager.STATE_CHECKING_UPDATE:
+      case AddonManager.STATE_INSTALLING:
+        // Installation is already running
+        break;
+      default:
+        throw new Error("Cannot start installing from this state");
+    }
+    return this._installPromise;
+  }
+
+  continuePostponedInstall() {
+    if (this.state !== AddonManager.STATE_POSTPONED) {
+      throw new Error("AddonInstall not in postponed state");
+    }
+
+    // Force the postponed install to continue.
+    logger.info(`${this.addon.id} has resumed a previously postponed upgrade`);
+    this.state = AddonManager.STATE_READY;
+    this.install();
+  }
+
+  /**
+   * Called during XPIProvider shutdown so that we can do any necessary
+   * pre-shutdown cleanup.
+   */
+  onShutdown() {
+    switch (this.state) {
+      case AddonManager.STATE_POSTPONED:
+        this.removeTemporaryFile();
+        break;
+    }
+  }
+
+  /**
+   * 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;
+        this._cleanup();
+        this._callInstallListeners("onDownloadCancelled");
+        this.removeTemporaryFile();
+        break;
+      case AddonManager.STATE_POSTPONED:
+        logger.debug(`Cancelling postponed install of ${this.addon.id}`);
+        this.state = AddonManager.STATE_CANCELLED;
+        this._cleanup();
+        this._callInstallListeners("onInstallCancelled");
+        this.removeTemporaryFile();
+
+        let stagingDir = this.location.installer.getStagingDir();
+        let stagedAddon = stagingDir.clone();
+
+        this.unstageInstall(stagedAddon);
+        break;
+      default:
+        throw new Error(
+          "Cannot cancel install of " +
+            this.sourceURI.spec +
+            " from this state (" +
+            this.state +
+            ")"
+        );
+    }
+  }
+
+  /**
+   * Adds an InstallListener for this instance if the listener is not already
+   * registered.
+   *
+   * @param {InstallListener} 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 {InstallListener} 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
+      );
+      flushJarCache(this.file);
+      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
+      );
+    }
+  }
+
+  _setFileHash(calculatedHash) {
+    this.fileHash = {
+      algorithm: this.hash ? this.hash.algorithm : DEFAULT_HASH_ALGO,
+      data: calculatedHash,
+    };
+
+    if (this.hash && calculatedHash != this.hash.data) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Updates the addon metadata that has to be propagated across restarts.
+   */
+  updatePersistedMetadata() {
+    this.addon.sourceURI = this.sourceURI.spec;
+
+    if (this.releaseNotesURI) {
+      this.addon.releaseNotesURI = this.releaseNotesURI.spec;
+    }
+
+    if (this.installTelemetryInfo) {
+      this.addon.installTelemetryInfo = this.installTelemetryInfo;
+    }
+  }
+
+  /**
+   * Called after the add-on is a local file and the signature and install
+   * manifest can be read.
+   *
+   * @param {nsIFile} file
+   *        The file from which to load the manifest.
+   * @returns {Promise<void>}
+   */
+  async loadManifest(file) {
+    let pkg;
+    try {
+      pkg = Package.get(file);
+    } catch (e) {
+      return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]);
+    }
+
+    try {
+      try {
+        this.addon = await loadManifest(pkg, this.location, this.existingAddon);
+      } catch (e) {
+        return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]);
+      }
+
+      if (!this.addon.id) {
+        let msg = `Cannot find id for addon ${file.path}.`;
+        if (Services.prefs.getBoolPref(PREF_XPI_SIGNATURES_DEV_ROOT, false)) {
+          msg += ` Preference ${PREF_XPI_SIGNATURES_DEV_ROOT} is set.`;
+        }
+
+        return Promise.reject([
+          AddonManager.ERROR_CORRUPT_FILE,
+          new Error(msg),
+        ]);
+      }
+
+      if (this.existingAddon) {
+        // Check various conditions related to upgrades
+        if (this.addon.id != this.existingAddon.id) {
+          return Promise.reject([
+            AddonManager.ERROR_INCORRECT_ID,
+            `Refusing to upgrade addon ${this.existingAddon.id} to different ID ${this.addon.id}`,
+          ]);
+        }
+
+        if (this.existingAddon.isWebExtension && !this.addon.isWebExtension) {
+          // This condition is never met on regular Firefox builds.
+          // Remove it along with externalExtensionLoaders (bug 1674799).
+          return Promise.reject([
+            AddonManager.ERROR_UNEXPECTED_ADDON_TYPE,
+            "WebExtensions may not be updated to other extension types",
+          ]);
+        }
+        if (this.existingAddon.type != this.addon.type) {
+          return Promise.reject([
+            AddonManager.ERROR_UNEXPECTED_ADDON_TYPE,
+            `Refusing to change addon type from ${this.existingAddon.type} to ${this.addon.type}`,
+          ]);
+        }
+
+        if (this.version !== this.addon.version) {
+          return Promise.reject([
+            AddonManager.ERROR_UNEXPECTED_ADDON_VERSION,
+            `Expected addon version ${this.version} instead of ${this.addon.version}`,
+          ]);
+        }
+      }
+
+      if (lazy.XPIDatabase.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;
+
+          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",
+          ]);
+        }
+      }
+    } finally {
+      pkg.close();
+    }
+
+    this.updatePersistedMetadata();
+
+    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 = await lazy.AddonRepository.getCachedAddonByID(
+      this.addon.id
+    );
+
+    // It wasn't there so try to re-download it
+    if (!repoAddon) {
+      try {
+        [repoAddon] = await lazy.AddonRepository.cacheAddons([this.addon.id]);
+      } catch (err) {
+        logger.debug(
+          `Error getting metadata for ${this.addon.id}: ${err.message}`
+        );
+      }
+    }
+
+    this.addon._repositoryAddon = repoAddon;
+    this.name = this.name || this.addon._repositoryAddon.name;
+    this.addon.appDisabled = !lazy.XPIDatabase.isUsableAddon(this.addon);
+    return undefined;
+  }
+
+  getIcon(desiredSize = 64) {
+    if (!this.addon.icons || !this.file) {
+      return null;
+    }
+
+    let { icon } = lazy.IconDetails.getPreferredIcon(
+      this.addon.icons,
+      null,
+      desiredSize
+    );
+    if (icon.startsWith("chrome://")) {
+      return icon;
+    }
+    return getJarURI(this.file, icon).spec;
+  }
+
+  /**
+   * This method should be called when the XPI is ready to be installed,
+   * i.e., when a download finishes or when a local file has been verified.
+   * It should only be called from install() when the install is in
+   * STATE_DOWNLOADED (which actually means that the file is available
+   * and has been verified).
+   */
+  checkPrompt() {
+    (async () => {
+      if (this.promptHandler) {
+        let info = {
+          existingAddon: this.existingAddon ? this.existingAddon.wrapper : null,
+          addon: this.addon.wrapper,
+          icon: this.getIcon(),
+          // Used in AMTelemetry to detect the install flow related to this prompt.
+          install: this.wrapper,
+        };
+
+        try {
+          await this.promptHandler(info);
+        } catch (err) {
+          if (this.error < 0) {
+            logger.info(`Install of ${this.addon.id} failed ${this.error}`);
+            this.state = AddonManager.STATE_INSTALL_FAILED;
+            this._cleanup();
+            // In some cases onOperationCancelled is called during failures
+            // to install/uninstall/enable/disable addons.  We may need to
+            // do that here in the future.
+            this._callInstallListeners("onInstallFailed");
+            this.removeTemporaryFile();
+          } else {
+            logger.info(`Install of ${this.addon.id} cancelled by user`);
+            this.state = AddonManager.STATE_CANCELLED;
+            this._cleanup();
+            this._callInstallListeners("onInstallCancelled");
+          }
+          return;
+        }
+      }
+      this.state = AddonManager.STATE_PROMPTS_DONE;
+      this.install();
+    })();
+  }
+
+  /**
+   * This method should be called when we have the XPI and any needed
+   * permissions prompts have been completed.  If there are any upgrade
+   * listeners, they are invoked and the install moves into STATE_POSTPONED.
+   * Otherwise, the install moves into STATE_INSTALLING
+   */
+  checkForBlockers() {
+    // 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 = () => {
+        this.continuePostponedInstall();
+      };
+      this.postpone(resumeFn);
+      return;
+    }
+
+    this.state = AddonManager.STATE_READY;
+    this.install();
+  }
+
+  /**
+   * Installs the add-on into the install location.
+   */
+  async startInstall() {
+    this.state = AddonManager.STATE_INSTALLING;
+    if (!this._callInstallListeners("onInstallStarted")) {
+      this.state = AddonManager.STATE_DOWNLOADED;
+      this.removeTemporaryFile();
+      this._cleanup();
+      this._callInstallListeners("onInstallCancelled");
+      return;
+    }
+
+    // Reinstall existing user-disabled addon (of the same installed version).
+    // If addon is marked to be uninstalled - don't reinstall it.
+    if (
+      this.existingAddon &&
+      this.existingAddon.location === this.location &&
+      this.existingAddon.version === this.addon.version &&
+      this.existingAddon.userDisabled &&
+      !this.existingAddon.pendingUninstall
+    ) {
+      await lazy.XPIDatabase.updateAddonDisabledState(this.existingAddon, {
+        userDisabled: false,
+      });
+      this.state = AddonManager.STATE_INSTALLED;
+      this._callInstallListeners("onInstallEnded", this.existingAddon.wrapper);
+      this._cleanup();
+      return;
+    }
+
+    let isSameLocation = this.existingAddon?.location == this.location;
+    let willActivate =
+      isSameLocation ||
+      !this.existingAddon ||
+      this.location.hasPrecedence(this.existingAddon.location);
+
+    logger.debug(
+      "Starting install of " + this.addon.id + " from " + this.sourceURI.spec
+    );
+    AddonManagerPrivate.callAddonListeners(
+      "onInstalling",
+      this.addon.wrapper,
+      false
+    );
+
+    let stagedAddon = this.location.installer.getStagingDir();
+
+    try {
+      await this.location.installer.requestStagingDir();
+
+      // remove any previously staged files
+      await this.unstageInstall(stagedAddon);
+
+      stagedAddon.append(`${this.addon.id}.xpi`);
+
+      await this.stageInstall(false, stagedAddon, isSameLocation);
+
+      this._cleanup();
+
+      let install = async () => {
+        // Mark this instance of the addon as inactive if it is being
+        // superseded by an addon in a different location.
+        if (
+          willActivate &&
+          this.existingAddon &&
+          this.existingAddon.active &&
+          !isSameLocation
+        ) {
+          lazy.XPIDatabase.updateAddonActive(this.existingAddon, false);
+        }
+
+        // Install the new add-on into its final location
+        let file = await this.location.installer.installAddon({
+          id: this.addon.id,
+          source: stagedAddon,
+        });
+
+        // Update the metadata in the database
+        this.addon.sourceBundle = file;
+        // If this addon will be the active addon, make it visible.
+        this.addon.visible = willActivate;
+
+        if (isSameLocation) {
+          this.addon = lazy.XPIDatabase.updateAddonMetadata(
+            this.existingAddon,
+            this.addon,
+            file.path
+          );
+          let state = this.location.get(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 = lazy.XPIDatabase.addToDatabase(this.addon, file.path);
+          lazy.XPIInternal.XPIStates.addAddon(this.addon);
+          this.addon.installDate = this.addon.updateDate;
+          lazy.XPIDatabase.saveChanges();
+        }
+        lazy.XPIInternal.XPIStates.save();
+
+        AddonManagerPrivate.callAddonListeners(
+          "onInstalled",
+          this.addon.wrapper
+        );
+
+        logger.debug(`Install of ${this.sourceURI.spec} completed.`);
+        this.state = AddonManager.STATE_INSTALLED;
+        this._callInstallListeners("onInstallEnded", this.addon.wrapper);
+
+        lazy.XPIDatabase.recordAddonTelemetry(this.addon);
+
+        // Notify providers that a new theme has been enabled.
+        if (this.addon.type === "theme" && this.addon.active) {
+          AddonManagerPrivate.notifyAddonChanged(
+            this.addon.id,
+            this.addon.type
+          );
+        }
+
+        // Clear the colorways builtins migrated to a non-builtin themes
+        // form the list of the retained themes.
+        if (
+          this.existingAddon?.isBuiltinColorwayTheme &&
+          !this.addon.isBuiltin &&
+          lazy.BuiltInThemesHelpers.isColorwayMigrationEnabled
+        ) {
+          lazy.BuiltInThemesHelpers.unretainMigratedColorwayTheme(
+            this.addon.id
+          );
+        }
+      };
+
+      this._startupPromise = (async () => {
+        if (!willActivate) {
+          await install();
+        } else if (this.existingAddon) {
+          await lazy.XPIInternal.BootstrapScope.get(this.existingAddon).update(
+            this.addon,
+            !this.addon.disabled,
+            install
+          );
+
+          if (this.addon.disabled) {
+            flushJarCache(this.file);
+          }
+        } else {
+          await install();
+          await lazy.XPIInternal.BootstrapScope.get(this.addon).install(
+            undefined,
+            true
+          );
+        }
+      })();
+
+      await this._startupPromise;
+    } catch (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;
+      this._cleanup();
+      AddonManagerPrivate.callAddonListeners(
+        "onOperationCancelled",
+        this.addon.wrapper
+      );
+      this._callInstallListeners("onInstallFailed");
+    } finally {
+      this.removeTemporaryFile();
+      this.location.installer.releaseStagingDir();
+    }
+  }
+
+  /**
+   * Stages an add-on for install.
+   *
+   * @param {boolean} restartRequired
+   *        If true, the final installation will be deferred until the
+   *        next app startup.
+   * @param {nsIFile} stagedAddon
+   *        The file where the add-on should be staged.
+   * @param {boolean} isSameLocation
+   *        True if this installation is an upgrade for an existing
+   *        add-on in the same location.
+   * @throws if the file cannot be staged.
+   */
+  async stageInstall(restartRequired, stagedAddon, isSameLocation) {
+    logger.debug(`Addon ${this.addon.id} will be installed as a packed xpi`);
+    stagedAddon.leafName = `${this.addon.id}.xpi`;
+
+    try {
+      await IOUtils.copy(this.file.path, stagedAddon.path);
+
+      let calculatedHash = getHashForFile(stagedAddon, this.fileHash.algorithm);
+      if (calculatedHash != this.fileHash.data) {
+        logger.warn(
+          `Staged file hash (${calculatedHash}) did not match initial hash (${this.fileHash.data})`
+        );
+        throw new Error("Refusing to stage add-on because it has been damaged");
+      }
+    } catch (e) {
+      await IOUtils.remove(stagedAddon.path, { ignoreAbsent: true });
+      throw e;
+    }
+
+    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
+      this.location.stageAddon(this.addon.id, this.addon.toJSON());
+
+      logger.debug(
+        `Staged install of ${this.addon.id} from ${this.sourceURI.spec} ready; waiting for restart.`
+      );
+      if (isSameLocation) {
+        delete this.existingAddon.pendingUpgrade;
+        this.existingAddon.pendingUpgrade = this.addon;
+      }
+    }
+  }
+
+  /**
+   * Removes any previously staged upgrade.
+   *
+   * @param {nsIFile} stagingDir
+   *        The staging directory from which to unstage the install.
+   */
+  async unstageInstall(stagingDir) {
+    this.location.unstageAddon(this.addon.id);
+
+    await removeAsync(getFile(this.addon.id, stagingDir));
+
+    await removeAsync(getFile(`${this.addon.id}.xpi`, stagingDir));
+  }
+
+  /**
+   * 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.
+   */
+  async postpone(resumeFn) {
+    this.state = AddonManager.STATE_POSTPONED;
+
+    let stagingDir = this.location.installer.getStagingDir();
+
+    try {
+      await this.location.installer.requestStagingDir();
+      await this.unstageInstall(stagingDir);
+
+      let stagedAddon = getFile(`${this.addon.id}.xpi`, stagingDir);
+
+      await this.stageInstall(true, stagedAddon, true);
+    } catch (e) {
+      logger.warn(`Failed to postpone install of ${this.addon.id}`, e);
+      this.state = AddonManager.STATE_INSTALL_FAILED;
+      this.error = AddonManager.ERROR_FILE_ACCESS;
+      this._cleanup();
+      this.removeTemporaryFile();
+      this.location.installer.releaseStagingDir();
+      this._callInstallListeners("onInstallFailed");
+      return;
+    }
+
+    this._callInstallListeners("onInstallPostponed");
+
+    // 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.location.installer.releaseStagingDir();
+  }
+
+  _callInstallListeners(event, ...args) {
+    switch (event) {
+      case "onDownloadCancelled":
+      case "onDownloadFailed":
+      case "onInstallCancelled":
+      case "onInstallFailed":
+        let rej = Promise.reject(new Error(`Install failed: ${event}`));
+        rej.catch(() => {});
+        this._resolveInstallPromise(rej);
+        break;
+      case "onInstallEnded":
+        this._resolveInstallPromise(
+          Promise.resolve(this._startupPromise).then(() => args[0])
+        );
+        break;
+    }
+    return AddonManagerPrivate.callInstallListeners(
+      event,
+      this.listeners,
+      this.wrapper,
+      ...args
+    );
+  }
+}
+
+var LocalAddonInstall = class extends AddonInstall {
+  /**
+   * Initialises this install to be an install from a local file.
+   */
+  async init() {
+    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;
+      this._cleanup();
+      return;
+    }
+
+    this.state = AddonManager.STATE_DOWNLOADED;
+    this.progress = this.file.fileSize;
+    this.maxProgress = this.file.fileSize;
+
+    let algorithm = this.hash ? this.hash.algorithm : DEFAULT_HASH_ALGO;
+    if (this.hash) {
+      try {
+        CryptoHash(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;
+        this._cleanup();
+        return;
+      }
+    }
+
+    if (!this._setFileHash(getHashForFile(this.file, algorithm))) {
+      logger.warn(
+        `File hash (${this.fileHash.data}) did not match provided hash (${this.hash.data})`
+      );
+      this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+      this.error = AddonManager.ERROR_INCORRECT_HASH;
+      this._cleanup();
+      return;
+    }
+
+    try {
+      await this.loadManifest(this.file);
+    } catch ([error, message]) {
+      logger.warn("Invalid XPI", message);
+      this.state = AddonManager.STATE_DOWNLOAD_FAILED;
+      this.error = error;
+      this._cleanup();
+      this._callInstallListeners("onNewInstall");
+      flushJarCache(this.file);
+      return;
+    }
+
+    let addon = await lazy.XPIDatabase.getVisibleAddonForID(this.addon.id);
+
+    this.existingAddon = addon;
+    this.addon.propagateDisabledState(this.existingAddon);
+    await this.addon.updateBlocklistState();
+    this.addon.updateDate = Date.now();
+    this.addon.installDate = addon ? addon.installDate : this.addon.updateDate;
+
+    // Report if blocked add-on becomes unblocked through this install.
+    if (
+      addon?.blocklistState === nsIBlocklistService.STATE_BLOCKED &&
+      this.addon.blocklistState === nsIBlocklistService.STATE_NOT_BLOCKED
+    ) {
+      this.addon.recordAddonBlockChangeTelemetry("addon_install");
+    }
+
+    if (!this.addon.isCompatible) {
+      this.state = AddonManager.STATE_CHECKING_UPDATE;
+
+      await new Promise(resolve => {
+        new UpdateChecker(
+          this.addon,
+          {
+            onUpdateFinished: aAddon => {
+              this.state = AddonManager.STATE_DOWNLOADED;
+              this._callInstallListeners("onNewInstall");
+              resolve();
+            },
+          },
+          AddonManager.UPDATE_WHEN_ADDON_INSTALLED
+        );
+      });
+    } else {
+      this._callInstallListeners("onNewInstall");
+    }
+  }
+
+  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 accommodate them here.
+      this._callInstallListeners("onDownloadFailed");
+      return this._installPromise;
+    }
+    return super.install();
+  }
+};
+
+var DownloadAddonInstall = class extends AddonInstall {
+  /**
+   * Instantiates a DownloadAddonInstall
+   *
+   * @param {XPIStateLocation} installLocation
+   *        The XPIStateLocation the add-on will be installed into
+   * @param {nsIURL} url
+   *        The nsIURL to get the add-on from
+   * @param {Object} [options = {}]
+   *        Additional options for the install
+   * @param {string} [options.hash]
+   *        An optional hash for the add-on
+   * @param {AddonInternal} [options.existingAddon]
+   *        The add-on this install will update if known
+   * @param {XULElement} [options.browser]
+   *        The browser performing the install, used to display
+   *        authentication prompts.
+   * @param {nsIPrincipal} [options.principal]
+   *        The principal to use. If not present, will default to browser.contentPrincipal.
+   * @param {string} [options.name]
+   *        An optional name for the add-on
+   * @param {string} [options.type]
+   *        An optional type for the add-on
+   * @param {Object} [options.icons]
+   *        Optional icons for the add-on
+   * @param {string} [options.version]
+   *        The expected version for the add-on.
+   *        Required for updates, i.e. when existingAddon is set.
+   * @param {function(string) : Promise<void>} [options.promptHandler]
+   *        A callback to prompt the user before installing.
+   * @param {boolean} [options.sendCookies]
+   *        Whether cookies should be sent when downloading the add-on.
+   */
+  constructor(installLocation, url, options = {}) {
+    super(installLocation, url, options);
+
+    this.browser = options.browser;
+    this.loadingPrincipal =
+      options.triggeringPrincipal ||
+      (this.browser && this.browser.contentPrincipal) ||
+      Services.scriptSecurityManager.getSystemPrincipal();
+    this.sendCookies = Boolean(options.sendCookies);
+
+    this.state = AddonManager.STATE_AVAILABLE;
+
+    this.stream = null;
+    this.crypto = null;
+    this.badCertHandler = null;
+    this.restartDownload = false;
+    this.downloadStartedAt = null;
+
+    this._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.fileHash = null;
+        this.startDownload();
+        break;
+      default:
+        return super.install();
+    }
+    return this._installPromise;
+  }
+
+  cancel() {
+    // If we're done downloading the file but still processing it we cannot
+    // cancel the installation. We just call the base class which will handle
+    // the request by throwing an error.
+    if (this.channel && this.state == AddonManager.STATE_DOWNLOADING) {
+      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.downloadStartedAt = Cu.now();
+
+    this.state = AddonManager.STATE_DOWNLOADING;
+    if (!this._callInstallListeners("onDownloadStarted")) {
+      logger.debug(
+        "onDownloadStarted listeners cancelled installation of addon " +
+          this.sourceURI.spec
+      );
+      this.state = AddonManager.STATE_CANCELLED;
+      this._cleanup();
+      this._callInstallListeners("onDownloadCancelled");
+      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 = new FileOutputStream(
+        this.file,
+        lazy.FileUtils.MODE_WRONLY |
+          lazy.FileUtils.MODE_CREATE |
+          lazy.FileUtils.MODE_TRUNCATE,
+        lazy.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;
+      this._cleanup();
+      this._callInstallListeners("onDownloadFailed");
+      return;
+    }
+
+    let listener = Cc[
+      "@mozilla.org/network/stream-listener-tee;1"
+    ].createInstance(Ci.nsIStreamListenerTee);
+    listener.init(this, this.stream);
+    try {
+      this.badCertHandler = new lazy.CertUtils.BadCertHandler(
+        !lazy.AddonSettings.INSTALL_REQUIREBUILTINCERTS
+      );
+
+      this.channel = lazy.NetUtil.newChannel({
+        uri: this.sourceURI,
+        securityFlags:
+          Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT,
+        contentPolicyType: Ci.nsIContentPolicy.TYPE_SAVEAS_DOWNLOAD,
+        loadingPrincipal: this.loadingPrincipal,
+      });
+      this.channel.notificationCallbacks = this;
+      if (this.sendCookies) {
+        if (this.channel instanceof Ci.nsIHttpChannelInternal) {
+          this.channel.forceAllowThirdPartyCookie = true;
+        }
+      } else {
+        this.channel.loadFlags |= Ci.nsIRequest.LOAD_ANONYMOUS;
+      }
+      this.channel.asyncOpen(listener);
+
+      Services.obs.addObserver(this, "network:offline-about-to-go-offline");
+    } 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;
+      this._cleanup();
+      this._callInstallListeners("onDownloadFailed");
+    }
+  }
+
+  /*
+   * Update the crypto hasher with the new data and call the progress listeners.
+   *
+   * @see nsIStreamListener
+   */
+  onDataAvailable(aRequest, aInputstream, aOffset, aCount) {
+    this.crypto.updateFromStream(aInputstream, aCount);
+    this.progress += aCount;
+    if (!this._callInstallListeners("onDownloadProgress")) {
+      // 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) {
+    if (this.hash) {
+      try {
+        this.crypto = CryptoHash(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;
+        this._cleanup();
+        this._callInstallListeners("onDownloadFailed");
+        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 = CryptoHash(DEFAULT_HASH_ALGO);
+    }
+
+    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, aStatus) {
+    this.stream.close();
+    this.channel = null;
+    this.badCerthandler = null;
+    Services.obs.removeObserver(this, "network:offline-about-to-go-offline");
+
+    let crypto = this.crypto;
+    this.crypto = null;
+
+    // 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;
+        this._cleanup();
+        this._callInstallListeners("onDownloadCancelled");
+        // 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 {
+            lazy.CertUtils.checkCert(
+              aRequest,
+              !lazy.AddonSettings.INSTALL_REQUIREBUILTINCERTS
+            );
+          } catch (e) {
+            this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, e);
+            return;
+          }
+        }
+
+        if (!this._setFileHash(getHashStringForCrypto(crypto))) {
+          this.downloadFailed(
+            AddonManager.ERROR_INCORRECT_HASH,
+            `Downloaded file hash (${this.fileHash.data}) 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_UPDATE;
+              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 {string} aReason
+   *        Something to log about the failure
+   * @param {integer} aError
+   *        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;
+    this._cleanup();
+    this._callInstallListeners("onDownloadFailed");
+
+    // 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.
+   */
+  async downloadCompleted() {
+    let wasUpdate = !!this.existingAddon;
+    let aAddon = await lazy.XPIDatabase.getVisibleAddonForID(this.addon.id);
+    if (aAddon) {
+      this.existingAddon = aAddon;
+    }
+
+    this.state = AddonManager.STATE_DOWNLOADED;
+    this.addon.updateDate = Date.now();
+
+    if (this.existingAddon) {
+      this.addon.installDate = this.existingAddon.installDate;
+    } else {
+      this.addon.installDate = this.addon.updateDate;
+    }
+    this.addon.propagateDisabledState(this.existingAddon);
+    await this.addon.updateBlocklistState();
+
+    // Report if blocked add-on becomes unblocked through this install/update.
+    if (
+      aAddon?.blocklistState === nsIBlocklistService.STATE_BLOCKED &&
+      this.addon.blocklistState === nsIBlocklistService.STATE_NOT_BLOCKED
+    ) {
+      this.addon.recordAddonBlockChangeTelemetry(
+        wasUpdate ? "addon_update" : "addon_install"
+      );
+    }
+
+    if (this._callInstallListeners("onDownloadEnded")) {
+      // If a listener changed our state then do not proceed with the install
+      if (this.state != AddonManager.STATE_DOWNLOADED) {
+        return;
+      }
+
+      // proceed with the install state machine.
+      this.install();
+    }
+  }
+
+  getInterface(iid) {
+    if (iid.equals(Ci.nsIAuthPrompt2)) {
+      let win = null;
+      if (this.browser) {
+        win = this.browser.contentWindow || this.browser.ownerGlobal;
+      }
+
+      let factory = Cc["@mozilla.org/prompter;1"].getService(
+        Ci.nsIPromptFactory
+      );
+      let prompt = factory.getPrompt(win, Ci.nsIAuthPrompt2);
+
+      if (this.browser && prompt instanceof Ci.nsILoginManagerAuthPrompter) {
+        prompt.browser = this.browser;
+      }
+
+      return prompt;
+    } else if (iid.equals(Ci.nsIChannelEventSink)) {
+      return this;
+    }
+
+    return this.badCertHandler.getInterface(iid);
+  }
+};
+
+/**
+ * Creates a new AddonInstall for an update.
+ *
+ * @param {function} aCallback
+ *        The callback to pass the new AddonInstall to
+ * @param {AddonInternal} aAddon
+ *        The add-on being updated
+ * @param {Object} aUpdate
+ *        The metadata about the new version from the update manifest
+ * @param {boolean} isUserRequested
+ *        An optional boolean, true if the install object is related to a user triggered update.
+ */
+function createUpdate(aCallback, aAddon, aUpdate, isUserRequested) {
+  let url = Services.io.newURI(aUpdate.updateURL);
+
+  (async function() {
+    let opts = {
+      hash: aUpdate.updateHash,
+      existingAddon: aAddon,
+      name: aAddon.selectedLocale.name,
+      type: aAddon.type,
+      icons: aAddon.icons,
+      version: aUpdate.version,
+      isUserRequestedUpdate: isUserRequested,
+    };
+
+    try {
+      if (aUpdate.updateInfoURL) {
+        opts.releaseNotesURI = Services.io.newURI(
+          escapeAddonURI(aAddon, aUpdate.updateInfoURL)
+        );
+      }
+    } catch (e) {
+      // If the releaseNotesURI cannot be parsed then just ignore it.
+    }
+
+    let install;
+    if (url instanceof Ci.nsIFileURL) {
+      install = new LocalAddonInstall(aAddon.location, url, opts);
+      await install.init();
+    } else {
+      let loc = aAddon.location;
+      if (
+        aAddon.isBuiltinColorwayTheme &&
+        lazy.BuiltInThemesHelpers.isColorwayMigrationEnabled
+      ) {
+        // Builtin colorways theme needs to be updated by installing the version
+        // got from AMO into the profile location and not using the location
+        // where the builtin addon is currently installed.
+        logger.info(
+          `Overriding location to APP_PROFILE on builtin colorway theme update for "${aAddon.id}"`
+        );
+        loc = lazy.XPIInternal.XPIStates.getLocation(
+          lazy.XPIInternal.KEY_APP_PROFILE
+        );
+      }
+      install = new DownloadAddonInstall(loc, url, opts);
+    }
+
+    aCallback(install);
+  })();
+}
+
+// Maps instances of AddonInstall to AddonInstallWrapper
+const wrapperMap = new WeakMap();
+let installFor = wrapper => wrapperMap.get(wrapper);
+
+// Numeric id included in the install telemetry events to correlate multiple events related
+// to the same install or update flow.
+let nextInstallId = 0;
+
+/**
+ * Creates a wrapper for an AddonInstall that only exposes the public API
+ *
+ * @param {AddonInstall} aInstall
+ *        The AddonInstall to create a wrapper for
+ */
+function AddonInstallWrapper(aInstall) {
+  wrapperMap.set(this, aInstall);
+  this.installId = ++nextInstallId;
+}
+
+AddonInstallWrapper.prototype = {
+  get __AddonInstallInternal__() {
+    return AppConstants.DEBUG ? installFor(this) : undefined;
+  },
+
+  get error() {
+    return installFor(this).error;
+  },
+
+  set error(err) {
+    installFor(this).error = err;
+  },
+
+  get type() {
+    return 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;
+  },
+
+  set promptHandler(handler) {
+    installFor(this).promptHandler = handler;
+  },
+
+  get promptHandler() {
+    return installFor(this).promptHandler;
+  },
+
+  get installTelemetryInfo() {
+    return installFor(this).installTelemetryInfo;
+  },
+
+  get isUserRequestedUpdate() {
+    return Boolean(installFor(this).isUserRequestedUpdate);
+  },
+
+  get downloadStartedAt() {
+    return installFor(this).downloadStartedAt;
+  },
+
+  get hashedAddonId() {
+    const addon = this.addon;
+
+    if (!addon) {
+      return null;
+    }
+
+    return computeSha256HashAsString(addon.id);
+  },
+
+  install() {
+    return installFor(this).install();
+  },
+
+  postpone(returnFn) {
+    return installFor(this).postpone(returnFn);
+  },
+
+  cancel() {
+    installFor(this).cancel();
+  },
+
+  continuePostponedInstall() {
+    return installFor(this).continuePostponedInstall();
+  },
+
+  addListener(listener) {
+    installFor(this).addListener(listener);
+  },
+
+  removeListener(listener) {
+    installFor(this).removeListener(listener);
+  },
+};
+
+[
+  "name",
+  "version",
+  "icons",
+  "releaseNotesURI",
+  "file",
+  "state",
+  "progress",
+  "maxProgress",
+].forEach(function(aProp) {
+  Object.defineProperty(AddonInstallWrapper.prototype, aProp, {
+    get() {
+      return installFor(this)[aProp];
+    },
+    enumerable: true,
+  });
+});
+
+/**
+ * Creates a new update checker.
+ *
+ * @param {AddonInternal} aAddon
+ *        The add-on to check for updates
+ * @param {UpdateListener} aListener
+ *        An UpdateListener to notify of updates
+ * @param {integer} aReason
+ *        The reason for the update check
+ * @param {string} [aAppVersion]
+ *        An optional application version to check for updates for
+ * @param {string} [aPlatformVersion]
+ *        An optional platform version to check for updates for
+ * @throws if the aListener or aReason arguments are not valid
+ */
+var AddonUpdateChecker;
+var UpdateChecker = function(
+  aAddon,
+  aListener,
+  aReason,
+  aAppVersion,
+  aPlatformVersion
+) {
+  if (!aListener || !aReason) {
+    throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
+  }
+
+  ({ AddonUpdateChecker } = ChromeUtils.import(
+    "resource://gre/modules/addons/AddonUpdateChecker.jsm"
+  ));
+
+  this.addon = aAddon;
+  aAddon._updateCheck = this;
+  XPIInstall.doing(this);
+  this.listener = aListener;
+  this.appVersion = aAppVersion;
+  this.platformVersion = aPlatformVersion;
+  this.syncCompatibility =
+    aReason == AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED;
+  this.isUserRequested = aReason == AddonManager.UPDATE_WHEN_USER_REQUESTED;
+
+  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, 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 {string} aMethod
+   *        The method to call on the listener
+   * @param {any[]} aArgs
+   *        Additional arguments to pass to the listener.
+   */
+  callListener(aMethod, ...aArgs) {
+    if (!(aMethod in this.listener)) {
+      return;
+    }
+
+    try {
+      this.listener[aMethod].apply(this.listener, aArgs);
+    } catch (e) {
+      logger.warn("Exception calling UpdateListener method " + aMethod, e);
+    }
+  },
+
+  /**
+   * Called when AddonUpdateChecker completes the update check
+   *
+   * @param {object[]} aUpdates
+   *        The list of update details for the add-on
+   */
+  async onUpdateCheckComplete(aUpdates) {
+    XPIInstall.done(this.addon._updateCheck);
+    this.addon._updateCheck = null;
+    let AUC = AddonUpdateChecker;
+    let ignoreMaxVersion = false;
+    // Ignore strict compatibility for dictionaries by default.
+    let ignoreStrictCompat = this.addon.type == "dictionary";
+    if (!AddonManager.checkCompatibility) {
+      ignoreMaxVersion = true;
+      ignoreStrictCompat = true;
+    } else if (
+      !AddonManager.strictCompatibility &&
+      !this.addon.strictCompatibility
+    ) {
+      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 update = await AUC.getNewestCompatibleUpdate(
+      aUpdates,
+      this.addon,
+      this.appVersion,
+      this.platformVersion,
+      ignoreMaxVersion,
+      ignoreStrictCompat
+    );
+
+    if (update && !this.addon.location.locked) {
+      for (let currentInstall of XPIInstall.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,
+        this.isUserRequested
+      );
+    } else {
+      sendUpdateAvailableMessages(this, null);
+    }
+  },
+
+  /**
+   * Called when AddonUpdateChecker fails the update check
+   *
+   * @param {any} aError
+   *        An error status
+   */
+  onUpdateCheckError(aError) {
+    XPIInstall.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() {
+    let parser = this._parser;
+    if (parser) {
+      this._parser = null;
+      // This will call back to onUpdateCheckError with a CANCELLED error
+      parser.cancel();
+    }
+  },
+};
+
+/**
+ * Creates a new AddonInstall to install an add-on from a local file.
+ *
+ * @param {nsIFile} file
+ *        The file to install
+ * @param {XPIStateLocation} location
+ *        The location to install to
+ * @param {Object?} [telemetryInfo]
+ *        An optional object which provides details about the installation source
+ *        included in the addon manager telemetry events.
+ * @returns {Promise<AddonInstall>}
+ *        A Promise that resolves with the new install object.
+ */
+function createLocalInstall(file, location, telemetryInfo) {
+  if (!location) {
+    location = lazy.XPIInternal.XPIStates.getLocation(
+      lazy.XPIInternal.KEY_APP_PROFILE
+    );
+  }
+  let url = Services.io.newFileURI(file);
+
+  try {
+    let install = new LocalAddonInstall(location, url, { telemetryInfo });
+    return install.init().then(() => install);
+  } catch (e) {
+    logger.error("Error creating install", e);
+    return Promise.resolve(null);
+  }
+}
+
+/**
+ * Uninstall an addon from a location.  This allows removing non-visible
+ * addons, such as system addon upgrades, when a higher precedence addon
+ * is installed.
+ *
+ * @param {string} addonID
+ *        ID of the addon being removed.
+ * @param {XPIStateLocation} location
+ *        The location to remove the addon from.
+ */
+async function uninstallAddonFromLocation(addonID, location) {
+  let existing = await lazy.XPIDatabase.getAddonInLocation(
+    addonID,
+    location.name
+  );
+  if (!existing) {
+    return;
+  }
+  if (existing.active) {
+    let a = await AddonManager.getAddonByID(addonID);
+    if (a) {
+      await a.uninstall();
+    }
+  } else {
+    lazy.XPIDatabase.removeAddonMetadata(existing);
+    location.removeAddon(addonID);
+    lazy.XPIInternal.XPIStates.save();
+    AddonManagerPrivate.callAddonListeners("onUninstalled", existing);
+  }
+}
+
+class DirectoryInstaller {
+  constructor(location) {
+    this.location = location;
+
+    this._stagingDirLock = 0;
+    this._stagingDirPromise = null;
+  }
+
+  get name() {
+    return this.location.name;
+  }
+
+  get dir() {
+    return this.location.dir;
+  }
+  set dir(val) {
+    this.location.dir = val;
+    this.location.path = val.path;
+  }
+
+  /**
+   * Gets the staging directory to put add-ons that are pending install and
+   * uninstall into.
+   *
+   * @returns {nsIFile}
+   */
+  getStagingDir() {
+    return getFile(lazy.XPIInternal.DIR_STAGE, this.dir);
+  }
+
+  requestStagingDir() {
+    this._stagingDirLock++;
+
+    if (this._stagingDirPromise) {
+      return this._stagingDirPromise;
+    }
+
+    let stagepath = PathUtils.join(this.dir.path, lazy.XPIInternal.DIR_STAGE);
+    return (this._stagingDirPromise = IOUtils.makeDirectory(stagepath, {
+      createAncestors: true,
+      ignoreExisting: true,
+    }).catch(e => {
+      logger.error("Failed to create staging directory", e);
+      throw e;
+    }));
+  }
+
+  releaseStagingDir() {
+    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 {string[]} [aLeafNames = []]
+   *        An array of file or directory to remove from the directory, the
+   *        array may be empty
+   */
+  cleanStagingDir(aLeafNames = []) {
+    let dir = this.getStagingDir();
+
+    for (let name of aLeafNames) {
+      let file = getFile(name, dir);
+      recursiveRemove(file);
+    }
+
+    if (this._stagingDirLock > 0) {
+      return;
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    for (let file of lazy.XPIInternal.iterDirectory(dir)) {
+      return;
+    }
+
+    try {
+      setFilePermissions(dir, lazy.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.
+   *
+   * @returns {nsIFile}
+   */
+  getTrashDir() {
+    let trashDir = getFile(lazy.XPIInternal.DIR_TRASH, this.dir);
+    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,
+        lazy.FileUtils.PERMS_DIRECTORY
+      );
+    }
+
+    return trashDir;
+  }
+
+  /**
+   * Installs an add-on into the install location.
+   *
+   * @param {Object} options
+   *        Installation options.
+   * @param {string} options.id
+   *        The ID of the add-on to install
+   * @param {nsIFile} options.source
+   *        The source nsIFile to install from
+   * @param {string} options.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
+   * @returns {nsIFile}
+   *        An nsIFile indicating where the add-on was installed to
+   */
+  installAddon({ id, source, action = "move" }) {
+    let trashDir = this.getTrashDir();
+
+    let transaction = new SafeInstallOperation();
+
+    let moveOldAddon = aId => {
+      let file = getFile(aId, this.dir);
+      if (file.exists()) {
+        transaction.moveUnder(file, trashDir);
+      }
+
+      file = getFile(`${aId}.xpi`, this.dir);
+      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 (action == "copy") {
+        transaction.copy(source, this.dir);
+      } else if (action == "move") {
+        flushJarCache(source);
+        transaction.moveUnder(source, this.dir);
+      }
+      // 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.dir.clone();
+
+    if (action == "proxy") {
+      // When permanently installing sideloaded addon, we just put a proxy file
+      // referring 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);
+    }
+
+    return newFile;
+  }
+
+  /**
+   * Uninstalls an add-on from this location.
+   *
+   * @param {string} aId
+   *        The ID of the add-on to uninstall
+   * @throws if the ID does not match any of the add-ons installed
+   */
+  uninstallAddon(aId) {
+    let file = getFile(aId, this.dir);
+    if (!file.exists()) {
+      file.leafName += ".xpi";
+    }
+
+    if (!file.exists()) {
+      logger.warn(
+        `Attempted to remove ${aId} from ${this.name} but it was already gone`
+      );
+      this.location.delete(aId);
+      return;
+    }
+
+    if (file.leafName != aId) {
+      logger.debug(
+        `uninstallAddon: flushing jar cache ${file.path} for addon ${aId}`
+      );
+      flushJarCache(file);
+    }
+
+    // In case this is a foreignInstall we do not want to remove the file if
+    // the location is locked.
+    if (!this.location.locked) {
+      let trashDir = this.getTrashDir();
+      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
+          );
+        }
+      }
+    }
+
+    this.location.removeAddon(aId);
+  }
+}
+
+class SystemAddonInstaller extends DirectoryInstaller {
+  constructor(location) {
+    super(location);
+
+    this._baseDir = location._baseDir;
+    this._nextDir = null;
+  }
+
+  get _addonSet() {
+    return this.location._addonSet;
+  }
+  set _addonSet(val) {
+    this.location._addonSet = val;
+  }
+
+  /**
+   * Saves the current set of system add-ons
+   *
+   * @param {Object} aAddonSet - object containing schema, directory and set
+   *                 of system add-on IDs and versions.
+   */
+  static _saveAddonSet(aAddonSet) {
+    Services.prefs.setStringPref(
+      lazy.XPIInternal.PREF_SYSTEM_ADDON_SET,
+      JSON.stringify(aAddonSet)
+    );
+  }
+
+  static _loadAddonSet() {
+    return lazy.XPIInternal.SystemAddonLocation._loadAddonSet();
+  }
+
+  /**
+   * Gets the staging directory to put add-ons that are pending install and
+   * uninstall into.
+   *
+   * @returns {nsIFile}
+   *        Staging directory for system add-on upgrades.
+   */
+  getStagingDir() {
+    this._addonSet = SystemAddonInstaller._loadAddonSet();
+    let dir = null;
+    if (this._addonSet.directory) {
+      this.dir = getFile(this._addonSet.directory, this._baseDir);
+      dir = getFile(lazy.XPIInternal.DIR_STAGE, this.dir);
+    } else {
+      logger.info("SystemAddonInstaller directory is missing");
+    }
+
+    return dir;
+  }
+
+  requestStagingDir() {
+    this._addonSet = SystemAddonInstaller._loadAddonSet();
+    if (this._addonSet.directory) {
+      this.dir = getFile(this._addonSet.directory, this._baseDir);
+    }
+    return super.requestStagingDir();
+  }
+
+  isValidAddon(aAddon) {
+    if (aAddon.appDisabled) {
+      logger.warn(
+        `System add-on ${aAddon.id} isn't compatible with the application.`
+      );
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Tests whether the loaded add-on information matches what is expected.
+   *
+   * @param {Map<string, AddonInternal>} aAddons
+   *        The set of add-ons to check.
+   * @returns {boolean}
+   *        True if all of the given add-ons are valid.
+   */
+  isValid(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.
+   */
+  async resetAddonSet() {
+    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.
+    let addonSet = this._addonSet;
+    this._addonSet = { schema: 1, addons: {} };
+    SystemAddonInstaller._saveAddonSet(this._addonSet);
+
+    // If this is running at app startup, the pref being cleared
+    // will cause later stages of startup to notice that the
+    // old updates are now gone.
+    //
+    // Updates will only be explicitly uninstalled if they are
+    // removed restartlessly, for instance if they are no longer
+    // part of the latest update set.
+    if (addonSet) {
+      for (let addonID of Object.keys(addonSet.addons)) {
+        await uninstallAddonFromLocation(addonID, this.location);
+      }
+    }
+  }
+
+  /**
+   * 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.
+   */
+  async cleanDirectories() {
+    try {
+      let children = await IOUtils.getChildren(this._baseDir.path, {
+        ignoreAbsent: true,
+      });
+      for (let path of children) {
+        // Skip the directory currently in use
+        if (this.dir && this.dir.path == path) {
+          continue;
+        }
+
+        // Skip the next directory
+        if (this._nextDir && this._nextDir.path == path) {
+          continue;
+        }
+
+        await IOUtils.remove(path, {
+          ignoreAbsent: true,
+          recursive: true,
+        });
+      }
+    } catch (e) {
+      logger.error("Failed to clean updated system add-ons directories.", e);
+    }
+  }
+
+  /**
+   * 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.
+   */
+  async installAddonSet(aAddons) {
+    // Make sure the base dir exists
+    await IOUtils.makeDirectory(this._baseDir.path, { ignoreExisting: true });
+
+    let addonSet = SystemAddonInstaller._loadAddonSet();
+
+    // Remove any add-ons that are no longer part of the set.
+    const ids = aAddons.map(a => a.id);
+    for (let addonID of Object.keys(addonSet.addons)) {
+      if (!ids.includes(addonID)) {
+        await uninstallAddonFromLocation(addonID, this.location);
+      }
+    }
+
+    let newDir = this._baseDir.clone();
+    newDir.append("blank");
+
+    while (true) {
+      newDir.leafName = Services.uuid.generateUUID().toString();
+      try {
+        await IOUtils.makeDirectory(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: {} };
+    SystemAddonInstaller._saveAddonSet(state);
+
+    this._nextDir = newDir;
+
+    let installs = [];
+    for (let addon of aAddons) {
+      let install = await createLocalInstall(
+        addon._sourceBundle,
+        this.location,
+        // Make sure that system addons being installed for the first time through
+        // Balrog have telemetryInfo associated with them (on the contrary the ones
+        // updated through Balrog but part of the build will already have the same
+        // `source`, but we expect no `method` to be set for them).
+        {
+          source: "system-addon",
+          method: "product-updates",
+        }
+      );
+      installs.push(install);
+    }
+
+    async function installAddon(install) {
+      // Make the new install own its temporary file.
+      install.ownsTempFile = true;
+      install.install();
+    }
+
+    async function postponeAddon(install) {
+      install.ownsTempFile = true;
+      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.location.installer.resumeAddonSet(installs);
+        };
+      }
+      await 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 = SystemAddonInstaller._loadAddonSet();
+      SystemAddonInstaller._saveAddonSet(state);
+
+      let blockers = aAddons.filter(addon =>
+        AddonManagerPrivate.hasUpgradeListener(addon.id)
+      );
+
+      if (blockers.length) {
+        await waitForAllPromises(installs.map(postponeAddon));
+      } else {
+        await waitForAllPromises(installs.map(installAddon));
+      }
+    } catch (e) {
+      // Roll back to previous upgrade set (if present) on restart.
+      if (previousState) {
+        SystemAddonInstaller._saveAddonSet(previousState);
+      }
+      // Otherwise, roll back to built-in set on restart.
+      // TODO try to do these restartlessly
+      await this.resetAddonSet();
+
+      try {
+        await IOUtils.remove(newDir.path, { recursive: 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.
+   *
+   * @param {AddonInstall[]} installs
+   *        The set of installs to resume.
+   */
+  async resumeAddonSet(installs) {
+    async function resumeAddon(install) {
+      install.state = AddonManager.STATE_DOWNLOADED;
+      install.location.installer.releaseStagingDir();
+      install.install();
+    }
+
+    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 {
+      await 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.
+   *
+   * @returns {nsIFile}
+   */
+  getTrashDir() {
+    let trashDir = getFile(lazy.XPIInternal.DIR_TRASH, this.dir);
+    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,
+        lazy.FileUtils.PERMS_DIRECTORY
+      );
+    }
+
+    return trashDir;
+  }
+
+  /**
+   * Installs an add-on into the install location.
+   *
+   * @param {string} id
+   *        The ID of the add-on to install
+   * @param {nsIFile} source
+   *        The source nsIFile to install from
+   * @returns {nsIFile}
+   *        An nsIFile indicating where the add-on was installed to
+   */
+  installAddon({ 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 {
+      flushJarCache(source);
+
+      transaction.moveUnder(source, this.dir);
+    } 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 = getFile(source.leafName, this.dir);
+
+    try {
+      newFile.lastModifiedTime = Date.now();
+    } catch (e) {
+      logger.warn("failed to set lastModifiedTime on " + newFile.path, e);
+    }
+
+    return newFile;
+  }
+
+  // old system add-on upgrade dirs get automatically removed
+  uninstallAddon(aAddon) {}
+}
+
+var AppUpdate = {
+  findAddonUpdates(addon, reason, appVersion, platformVersion) {
+    return new Promise((resolve, reject) => {
+      let update = null;
+      addon.findUpdates(
+        {
+          onUpdateAvailable(addon2, install) {
+            update = install;
+          },
+
+          onUpdateFinished(addon2, error) {
+            if (error == AddonManager.UPDATE_STATUS_NO_ERROR) {
+              resolve(update);
+            } else {
+              reject(error);
+            }
+          },
+        },
+        reason,
+        appVersion,
+        platformVersion || appVersion
+      );
+    });
+  },
+
+  stageInstall(installer) {
+    return new Promise((resolve, reject) => {
+      let listener = {
+        onDownloadEnded: install => {
+          install.postpone();
+        },
+        onInstallFailed: install => {
+          install.removeListener(listener);
+          reject();
+        },
+        onInstallEnded: install => {
+          // We shouldn't end up here, but if we do, resolve
+          // since we've installed.
+          install.removeListener(listener);
+          resolve();
+        },
+        onInstallPostponed: install => {
+          // At this point the addon is staged for restart.
+          install.removeListener(listener);
+          resolve();
+        },
+      };
+
+      installer.addListener(listener);
+      installer.install();
+    });
+  },
+
+  async stageLangpackUpdates(nextVersion, nextPlatformVersion) {
+    let updates = [];
+    let addons = await AddonManager.getAddonsByTypes(["locale"]);
+    for (let addon of addons) {
+      updates.push(
+        this.findAddonUpdates(
+          addon,
+          AddonManager.UPDATE_WHEN_NEW_APP_DETECTED,
+          nextVersion,
+          nextPlatformVersion
+        )
+          .then(update => update && this.stageInstall(update))
+          .catch(e => {
+            logger.debug(`addon.findUpdate error: ${e}`);
+          })
+      );
+    }
+    return Promise.all(updates);
+  },
+};
+
+var XPIInstall = {
+  // An array of currently active AddonInstalls
+  installs: new Set(),
+
+  createLocalInstall,
+  flushJarCache,
+  newVersionReason,
+  recursiveRemove,
+  syncLoadManifest,
+  loadManifestFromFile,
+  uninstallAddonFromLocation,
+
+  stageLangpacksForAppUpdate(nextVersion, nextPlatformVersion) {
+    return AppUpdate.stageLangpackUpdates(nextVersion, nextPlatformVersion);
+  },
+
+  // Keep track of in-progress operations that support cancel()
+  _inProgress: [],
+
+  doing(aCancellable) {
+    this._inProgress.push(aCancellable);
+  },
+
+  done(aCancellable) {
+    let i = this._inProgress.indexOf(aCancellable);
+    if (i != -1) {
+      this._inProgress.splice(i, 1);
+      return true;
+    }
+    return false;
+  },
+
+  cancelAll() {
+    // Cancelling one may alter _inProgress, so don't use a simple iterator
+    while (this._inProgress.length) {
+      let c = this._inProgress.shift();
+      try {
+        c.cancel();
+      } catch (e) {
+        logger.warn("Cancel failed", e);
+      }
+    }
+  },
+
+  /**
+   * @param {string} id
+   *        The expected ID of the add-on.
+   * @param {nsIFile} file
+   *        The XPI file to install the add-on from.
+   * @param {XPIStateLocation} location
+   *        The install location to install the add-on to.
+   * @param {string?} [oldAppVersion]
+   *        The version of the application last run with this profile or null
+   *        if it is a new profile or the version is unknown
+   * @returns {AddonInternal}
+   *        The installed Addon object, upon success.
+   */
+  async installDistributionAddon(id, file, location, oldAppVersion) {
+    let addon = await loadManifestFromFile(file, location);
+    addon.installTelemetryInfo = { source: "distribution" };
+
+    if (addon.id != id) {
+      throw new Error(
+        `File file ${file.path} contains an add-on with an incorrect ID`
+      );
+    }
+
+    let state = location.get(id);
+
+    if (state) {
+      try {
+        let existingAddon = await loadManifestFromFile(state.file, location);
+
+        if (Services.vc.compare(addon.version, existingAddon.version) <= 0) {
+          return null;
+        }
+      } 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 ${state.path}, overwriting`,
+          e
+        );
+      }
+    } else if (
+      addon.type === "locale" &&
+      oldAppVersion &&
+      Services.vc.compare(oldAppVersion, "67") < 0
+    ) {
+      /* Distribution language packs didn't get installed due to the signing
+           issues so we need to force them to be reinstalled. */
+      Services.prefs.clearUserPref(
+        lazy.XPIInternal.PREF_BRANCH_INSTALLED_ADDON + id
+      );
+    } else if (
+      Services.prefs.getBoolPref(
+        lazy.XPIInternal.PREF_BRANCH_INSTALLED_ADDON + id,
+        false
+      )
+    ) {
+      return null;
+    }
+
+    // Install the add-on
+    addon.sourceBundle = location.installer.installAddon({
+      id,
+      source: file,
+      action: "copy",
+    });
+
+    lazy.XPIInternal.XPIStates.addAddon(addon);
+    logger.debug(`Installed distribution add-on ${id}`);
+
+    Services.prefs.setBoolPref(
+      lazy.XPIInternal.PREF_BRANCH_INSTALLED_ADDON + id,
+      true
+    );
+
+    return addon;
+  },
+
+  /**
+   * Completes the install of an add-on which was staged during the last
+   * session.
+   *
+   * @param {string} id
+   *        The expected ID of the add-on.
+   * @param {object} metadata
+   *        The parsed metadata for the staged install.
+   * @param {XPIStateLocation} location
+   *        The install location to install the add-on to.
+   * @returns {AddonInternal}
+   *        The installed Addon object, upon success.
+   */
+  async installStagedAddon(id, metadata, location) {
+    let source = getFile(`${id}.xpi`, location.installer.getStagingDir());
+
+    // Check that the directory's name is a valid ID.
+    if (!gIDTest.test(id) || !source.exists() || !source.isFile()) {
+      throw new Error(`Ignoring invalid staging directory entry: ${id}`);
+    }
+
+    let addon = await loadManifestFromFile(source, location);
+
+    if (
+      lazy.XPIDatabase.mustSign(addon.type) &&
+      addon.signedState <= AddonManager.SIGNEDSTATE_MISSING
+    ) {
+      throw new Error(
+        `Refusing to install staged add-on ${id} with signed state ${addon.signedState}`
+      );
+    }
+
+    // Import saved metadata before checking for compatibility.
+    addon.importMetadata(metadata);
+
+    // Ensure a staged addon is compatible with the current running version of
+    // Firefox.  If a prior version of the addon is installed, it will remain.
+    if (!addon.isCompatible) {
+      throw new Error(
+        `Add-on ${addon.id} is not compatible with application version.`
+      );
+    }
+
+    logger.debug(`Processing install of ${id} in ${location.name}`);
+    let existingAddon = lazy.XPIInternal.XPIStates.findAddon(id);
+    // This part of the startup file changes is called from
+    // processPendingFileChanges, no addons are started yet.
+    // Here we handle copying the xpi into its proper place, later
+    // processFileChanges will call update.
+    try {
+      addon.sourceBundle = location.installer.installAddon({
+        id,
+        source,
+      });
+      lazy.XPIInternal.XPIStates.addAddon(addon);
+    } catch (e) {
+      if (existingAddon) {
+        // Re-install the old add-on
+        lazy.XPIInternal.get(existingAddon).install();
+      }
+      throw e;
+    }
+
+    return addon;
+  },
+
+  async updateSystemAddons() {
+    let systemAddonLocation = lazy.XPIInternal.XPIStates.getLocation(
+      lazy.XPIInternal.KEY_APP_SYSTEM_ADDONS
+    );
+    if (!systemAddonLocation) {
+      return;
+    }
+
+    let installer = systemAddonLocation.installer;
+
+    // Don't do anything in safe mode
+    if (Services.appinfo.inSafeMode) {
+      return;
+    }
+
+    // Download the list of system add-ons
+    let url = Services.prefs.getStringPref(PREF_SYSTEM_ADDON_UPDATE_URL, null);
+    if (!url) {
+      await installer.cleanDirectories();
+      return;
+    }
+
+    url = await lazy.UpdateUtils.formatUpdateURL(url);
+
+    logger.info(`Starting system add-on update check from ${url}.`);
+    let res = await lazy.ProductAddonChecker.getProductAddonList(
+      url,
+      true
+    ).catch(e => logger.error(`System addon update list error ${e}`));
+
+    // If there was no list then do nothing.
+    if (!res || !res.addons) {
+      logger.info("No system add-ons list was returned.");
+      await installer.cleanDirectories();
+      return;
+    }
+
+    let addonList = new Map(
+      res.addons.map(spec => [spec.id, { spec, path: null, addon: null }])
+    );
+
+    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(
+      await lazy.XPIDatabase.getAddonsInLocation(
+        lazy.XPIInternal.KEY_APP_SYSTEM_ADDONS
+      )
+    );
+    if (setMatches(addonList, updatedAddons)) {
+      logger.info("Retaining existing updated system add-ons.");
+      await installer.cleanDirectories();
+      return;
+    }
+
+    // If this matches the current set in the default location then reset the
+    // updated set.
+    let defaultAddons = addonMap(
+      await lazy.XPIDatabase.getAddonsInLocation(
+        lazy.XPIInternal.KEY_APP_SYSTEM_DEFAULTS
+      )
+    );
+    if (setMatches(addonList, defaultAddons)) {
+      logger.info("Resetting system add-ons.");
+      await installer.resetAddonSet();
+      await installer.cleanDirectories();
+      return;
+    }
+
+    // Download all the add-ons
+    async function downloadAddon(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. We later mark the install object with
+          // ownsTempFile so that we will cleanup later (see installAddonSet).
+          try {
+            let tmpDir = Services.dirsvc.get("TmpD", Ci.nsIFile).path;
+            let uniquePath = await IOUtils.createUniqueFile(tmpDir, "tmpaddon");
+            await IOUtils.copy(sourceAddon._sourceBundle.path, uniquePath);
+            // Make sure to update file modification times so this is detected
+            // as a new add-on.
+            await IOUtils.setModificationTime(uniquePath);
+            item.path = uniquePath;
+          } catch (e) {
+            logger.warn(
+              `Failed make temporary copy of ${sourceAddon._sourceBundle.path}.`,
+              e
+            );
+          }
+        }
+        if (!item.path) {
+          item.path = await lazy.ProductAddonChecker.downloadAddon(item.spec);
+        }
+        item.addon = await loadManifestFromFile(
+          nsIFile(item.path),
+          systemAddonLocation
+        );
+      } catch (e) {
+        logger.error(`Failed to download system add-on ${item.spec.id}`, e);
+      }
+    }
+    await 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 (!installer.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");
+    await installer.installAddonSet(
+      Array.from(addonList.values()).map(a => a.addon)
+    );
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons is enabled.
+   *
+   * @returns {boolean}
+   *        True if installing is enabled.
+   */
+  isInstallEnabled() {
+    // Default to enabled if the preference does not exist
+    return Services.prefs.getBoolPref(PREF_XPI_ENABLED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons by direct URL requests is
+   * whitelisted.
+   *
+   * @returns {boolean}
+   *        True if installing by direct requests is whitelisted
+   */
+  isDirectRequestWhitelisted() {
+    // Default to whitelisted if the preference does not exist.
+    return Services.prefs.getBoolPref(PREF_XPI_DIRECT_WHITELISTED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons from file referrers is
+   * whitelisted.
+   *
+   * @returns {boolean}
+   *       True if installing from file referrers is whitelisted
+   */
+  isFileRequestWhitelisted() {
+    // Default to whitelisted if the preference does not exist.
+    return Services.prefs.getBoolPref(PREF_XPI_FILE_WHITELISTED, true);
+  },
+
+  /**
+   * Called to test whether installing XPI add-ons from a URI is allowed.
+   *
+   * @param {nsIPrincipal}  aInstallingPrincipal
+   *        The nsIPrincipal that initiated the install
+   * @returns {boolean}
+   *        True if installing is allowed
+   */
+  isInstallAllowed(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;
+    }
+
+    lazy.XPIDatabase.importPermissions();
+
+    let permission = Services.perms.testPermissionFromPrincipal(
+      aInstallingPrincipal,
+      lazy.XPIInternal.XPI_PERMISSION
+    );
+    if (permission == Ci.nsIPermissionManager.DENY_ACTION) {
+      return false;
+    }
+
+    let requireWhitelist = Services.prefs.getBoolPref(
+      PREF_XPI_WHITELIST_REQUIRED,
+      true
+    );
+    if (
+      requireWhitelist &&
+      permission != Ci.nsIPermissionManager.ALLOW_ACTION
+    ) {
+      return false;
+    }
+
+    let requireSecureOrigin = Services.prefs.getBoolPref(
+      PREF_INSTALL_REQUIRESECUREORIGIN,
+      true
+    );
+    let safeSchemes = ["https", "chrome", "file"];
+    if (requireSecureOrigin && !safeSchemes.includes(uri.scheme)) {
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Called to get an AddonInstall to download and install an add-on from a URL.
+   *
+   * @param {nsIURI} aUrl
+   *        The URL to be installed
+   * @param {object} [aOptions]
+   *        Additional options for this install.
+   * @param {string?} [aOptions.hash]
+   *        A hash for the install
+   * @param {string} [aOptions.name]
+   *        A name for the install
+   * @param {Object} [aOptions.icons]
+   *        Icon URLs for the install
+   * @param {string} [aOptions.version]
+   *        A version for the install
+   * @param {XULElement} [aOptions.browser]
+   *        The browser performing the install
+   * @param {Object} [aOptions.telemetryInfo]
+   *        An optional object which provides details about the installation source
+   *        included in the addon manager telemetry events.
+   * @param {boolean} [aOptions.sendCookies = false]
+   *        Whether cookies should be sent when downloading the add-on.
+   * @param {string} [aOptions.useSystemLocation = false]
+   *        If true installs to the system profile location.
+   * @returns {AddonInstall}
+   */
+  async getInstallForURL(aUrl, aOptions) {
+    let locationName = aOptions.useSystemLocation
+      ? lazy.XPIInternal.KEY_APP_SYSTEM_PROFILE
+      : lazy.XPIInternal.KEY_APP_PROFILE;
+    let location = lazy.XPIInternal.XPIStates.getLocation(locationName);
+    if (!location) {
+      throw Components.Exception(
+        "Invalid location name",
+        Cr.NS_ERROR_INVALID_ARG
+      );
+    }
+
+    let url = Services.io.newURI(aUrl);
+
+    if (url instanceof Ci.nsIFileURL) {
+      let install = new LocalAddonInstall(location, url, aOptions);
+      await install.init();
+      return install.wrapper;
+    }
+
+    let install = new DownloadAddonInstall(location, url, aOptions);
+    return install.wrapper;
+  },
+
+  /**
+   * Called to get an AddonInstall to install an add-on from a local file.
+   *
+   * @param {nsIFile} aFile
+   *        The file to be installed
+   * @param {Object?} [aInstallTelemetryInfo]
+   *        An optional object which provides details about the installation source
+   *        included in the addon manager telemetry events.
+   * @param {boolean} [aUseSystemLocation = false]
+   *        If true install to the system profile location.
+   * @returns {AddonInstall?}
+   */
+  async getInstallForFile(
+    aFile,
+    aInstallTelemetryInfo,
+    aUseSystemLocation = false
+  ) {
+    let location = lazy.XPIInternal.XPIStates.getLocation(
+      aUseSystemLocation
+        ? lazy.XPIInternal.KEY_APP_SYSTEM_PROFILE
+        : lazy.XPIInternal.KEY_APP_PROFILE
+    );
+    let install = await createLocalInstall(
+      aFile,
+      location,
+      aInstallTelemetryInfo
+    );
+    return install ? install.wrapper : null;
+  },
+
+  /**
+   * Called to get the current AddonInstalls, optionally limiting to a list of
+   * types.
+   *
+   * @param {Array<string>?} aTypes
+   *        An array of types or null to get all types
+   * @returns {AddonInstall[]}
+   */
+  getInstallsByTypes(aTypes) {
+    let results = [...this.installs];
+    if (aTypes) {
+      results = results.filter(install => {
+        return aTypes.includes(install.type);
+      });
+    }
+
+    return results.map(install => install.wrapper);
+  },
+
+  /**
+   * 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 {nsIFile} aFile
+   *        An nsIFile for the unpacked add-on directory or XPI file.
+   *
+   * @returns {Promise<Addon>}
+   *        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.
+   */
+  async installTemporaryAddon(aFile) {
+    let installLocation = lazy.XPIInternal.TemporaryInstallLocation;
+
+    if (lazy.XPIInternal.isXPI(aFile.leafName)) {
+      flushJarCache(aFile);
+    }
+    let addon = await loadManifestFromFile(aFile, installLocation);
+    addon.rootURI = lazy.XPIInternal.getURIForResourceInFile(aFile, "").spec;
+
+    await this._activateAddon(addon, { temporarilyInstalled: true });
+
+    logger.debug(`Install of temporary addon in ${aFile.path} completed.`);
+    return addon.wrapper;
+  },
+
+  /**
+   * Installs an add-on from a built-in location
+   *  (ie a resource: url referencing assets shipped with the application)
+   *
+   * @param  {string} base
+   *         A string containing the base URL.  Must be a resource: URL.
+   * @returns {Promise<Addon>}
+   *          A Promise that resolves to an Addon object when the addon is
+   *          installed.
+   */
+  async installBuiltinAddon(base) {
+    // We have to get this before the install, as the install will overwrite
+    // the pref. We then keep the value for this run, so we can restore
+    // the selected theme once it becomes available.
+    if (lastSelectedTheme === null) {
+      lastSelectedTheme = Services.prefs.getCharPref(PREF_SELECTED_THEME, "");
+    }
+
+    let baseURL = Services.io.newURI(base);
+
+    // WebExtensions need to be able to iterate through the contents of
+    // an extension (for localization).  It knows how to do this with
+    // jar: and file: URLs, so translate the provided base URL to
+    // something it can use.
+    if (baseURL.scheme !== "resource") {
+      throw new Error("Built-in addons must use resource: URLS");
+    }
+
+    let pkg = builtinPackage(baseURL);
+    let addon = await loadManifest(pkg, lazy.XPIInternal.BuiltInLocation);
+    addon.rootURI = base;
+
+    // If this is a theme, decide whether to enable it. Themes are
+    // disabled by default. However:
+    //
+    // We always want one theme to be active, falling back to the
+    // default theme when the active theme is disabled.
+    // During a theme migration, such as a change in the path to the addon, we
+    // will need to ensure a correct theme is enabled.
+    if (addon.type === "theme") {
+      if (
+        addon.id === lastSelectedTheme ||
+        (!lastSelectedTheme.endsWith("@mozilla.org") &&
+          addon.id === lazy.AddonSettings.DEFAULT_THEME_ID &&
+          !lazy.XPIDatabase.getAddonsByType("theme").some(
+            theme => !theme.disabled
+          ))
+      ) {
+        addon.userDisabled = false;
+      }
+    }
+    await this._activateAddon(addon);
+    return addon.wrapper;
+  },
+
+  /**
+   * Activate a newly installed addon.
+   * This function handles all the bookkeeping related to a new addon
+   * and invokes whatever bootstrap methods are necessary.
+   * Note that this function is only used for temporary and built-in
+   * installs, it is very similar to AddonInstall::startInstall().
+   * It would be great to merge this function with that one some day.
+   *
+   * @param {AddonInternal} addon  The addon to activate
+   * @param {object} [extraParams] Any extra parameters to pass to the
+   *                               bootstrap install() method
+   *
+   * @returns {Promise<void>}
+   */
+  async _activateAddon(addon, extraParams = {}) {
+    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);
+    }
+
+    let oldAddon = await lazy.XPIDatabase.getVisibleAddonForID(addon.id);
+
+    let willActivate =
+      !oldAddon ||
+      oldAddon.location == addon.location ||
+      addon.location.hasPrecedence(oldAddon.location);
+
+    let install = () => {
+      addon.visible = willActivate;
+      // Themes are generally not enabled by default at install time,
+      // unless enabled by the front-end code. If they are meant to be
+      // enabled, they will already have been enabled by this point.
+      if (addon.type !== "theme" || addon.location.isTemporary) {
+        addon.userDisabled = false;
+      }
+      addon.active = addon.visible && !addon.disabled;
+
+      addon = lazy.XPIDatabase.addToDatabase(
+        addon,
+        addon._sourceBundle ? addon._sourceBundle.path : null
+      );
+
+      lazy.XPIInternal.XPIStates.addAddon(addon);
+      lazy.XPIInternal.XPIStates.save();
+    };
+
+    AddonManagerPrivate.callAddonListeners("onInstalling", addon.wrapper);
+
+    if (!willActivate) {
+      addon.installDate = Date.now();
+
+      install();
+    } else if (oldAddon) {
+      logger.warn(
+        `Addon with ID ${oldAddon.id} already installed, ` +
+          "older version will be disabled"
+      );
+
+      addon.installDate = oldAddon.installDate;
+
+      await lazy.XPIInternal.BootstrapScope.get(oldAddon).update(
+        addon,
+        true,
+        install
+      );
+    } else {
+      addon.installDate = Date.now();
+
+      install();
+      let bootstrap = lazy.XPIInternal.BootstrapScope.get(addon);
+      await bootstrap.install(undefined, true, extraParams);
+    }
+
+    AddonManagerPrivate.callInstallListeners(
+      "onExternalInstall",
+      null,
+      addon.wrapper,
+      oldAddon ? oldAddon.wrapper : null,
+      false
+    );
+    AddonManagerPrivate.callAddonListeners("onInstalled", addon.wrapper);
+
+    // Notify providers that a new theme has been enabled.
+    if (addon.type === "theme" && !addon.userDisabled) {
+      AddonManagerPrivate.notifyAddonChanged(addon.id, addon.type, false);
+    }
+  },
+
+  /**
+   * Uninstalls an add-on, immediately if possible or marks it as pending
+   * uninstall if not.
+   *
+   * @param {DBAddonInternal} aAddon
+   *        The DBAddonInternal to uninstall
+   * @param {boolean} aForcePending
+   *        Force this addon into the pending uninstall state (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
+   */
+  async uninstallAddon(aAddon, aForcePending) {
+    if (!aAddon.inDatabase) {
+      throw new Error(
+        `Cannot uninstall addon ${aAddon.id} because it is not installed`
+      );
+    }
+    let { location } = aAddon;
+
+    // If the addon is sideloaded into a location that does not allow
+    // sideloads, it is a legacy sideload.  We allow those to be uninstalled.
+    let isLegacySideload =
+      aAddon.foreignInstall &&
+      !(location.scope & lazy.AddonSettings.SCOPES_SIDELOAD);
+
+    if (location.locked && !isLegacySideload) {
+      throw new Error(
+        `Cannot uninstall addon ${aAddon.id} ` +
+          `from locked install location ${location.name}`
+      );
+    }
+
+    if (aForcePending && aAddon.pendingUninstall) {
+      throw new Error("Add-on is already marked to be uninstalled");
+    }
+
+    if (aAddon._updateCheck) {
+      logger.debug(`Cancel in-progress update check for ${aAddon.id}`);
+      aAddon._updateCheck.cancel();
+    }
+
+    let wasActive = aAddon.active;
+    let wasPending = aAddon.pendingUninstall;
+
+    if (aForcePending) {
+      // 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.location.isTemporary && aAddon.location.installer) {
+        let stage = getFile(
+          aAddon.id,
+          aAddon.location.installer.getStagingDir()
+        );
+        if (!stage.exists()) {
+          stage.create(
+            Ci.nsIFile.DIRECTORY_TYPE,
+            lazy.FileUtils.PERMS_DIRECTORY
+          );
+        }
+      }
+
+      lazy.XPIDatabase.setAddonProperties(aAddon, {
+        pendingUninstall: true,
+      });
+      Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+      let xpiState = aAddon.location.get(aAddon.id);
+      if (xpiState) {
+        xpiState.enabled = false;
+        lazy.XPIInternal.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) {
+      AddonManagerPrivate.callAddonListeners(
+        "onUninstalling",
+        wrapper,
+        !!aForcePending
+      );
+    }
+
+    let existingAddon = lazy.XPIInternal.XPIStates.findAddon(
+      aAddon.id,
+      loc => loc != aAddon.location
+    );
+
+    let bootstrap = lazy.XPIInternal.BootstrapScope.get(aAddon);
+    if (!aForcePending) {
+      let existing;
+      if (existingAddon) {
+        existing = await lazy.XPIDatabase.getAddonInLocation(
+          aAddon.id,
+          existingAddon.location.name
+        );
+      }
+
+      let uninstall = () => {
+        lazy.XPIInternal.XPIStates.disableAddon(aAddon.id);
+        if (aAddon.location.installer) {
+          aAddon.location.installer.uninstallAddon(aAddon.id);
+        }
+        lazy.XPIDatabase.removeAddonMetadata(aAddon);
+        aAddon.location.removeAddon(aAddon.id);
+        AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);
+
+        // Migrate back to the existing addon, unless it was a builtin colorway theme.
+        if (
+          existing &&
+          !(
+            existing.isBuiltinColorwayTheme &&
+            lazy.BuiltInThemesHelpers.isColorwayMigrationEnabled
+          )
+        ) {
+          lazy.XPIDatabase.makeAddonVisible(existing);
+          AddonManagerPrivate.callAddonListeners(
+            "onInstalling",
+            existing.wrapper,
+            false
+          );
+
+          if (!existing.disabled) {
+            lazy.XPIDatabase.updateAddonActive(existing, true);
+          }
+        }
+      };
+
+      // Migrate back to the existing addon, unless it was a builtin colorway theme.
+      if (
+        existing &&
+        !(
+          existing.isBuiltinColorwayTheme &&
+          lazy.BuiltInThemesHelpers.isColorwayMigrationEnabled
+        )
+      ) {
+        await bootstrap.update(existing, !existing.disabled, uninstall);
+
+        AddonManagerPrivate.callAddonListeners("onInstalled", existing.wrapper);
+      } else {
+        aAddon.location.removeAddon(aAddon.id);
+        await bootstrap.uninstall();
+        uninstall();
+      }
+    } else if (aAddon.active) {
+      lazy.XPIInternal.XPIStates.disableAddon(aAddon.id);
+      bootstrap.shutdown(lazy.XPIInternal.BOOTSTRAP_REASONS.ADDON_UNINSTALL);
+      lazy.XPIDatabase.updateAddonActive(aAddon, false);
+    }
+
+    // Notify any other providers that a new theme has been enabled
+    // (when the active theme is uninstalled, the default theme is enabled).
+    if (aAddon.type === "theme" && wasActive) {
+      AddonManagerPrivate.notifyAddonChanged(null, aAddon.type);
+    }
+  },
+
+  /**
+   * Cancels the pending uninstall of an add-on.
+   *
+   * @param {DBAddonInternal} aAddon
+   *        The DBAddonInternal to cancel uninstall for
+   */
+  cancelUninstallAddon(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.location.isTemporary && aAddon.location.installer) {
+      aAddon.location.installer.cleanStagingDir([aAddon.id]);
+    }
+
+    lazy.XPIDatabase.setAddonProperties(aAddon, {
+      pendingUninstall: false,
+    });
+
+    if (!aAddon.visible) {
+      return;
+    }
+
+    aAddon.location.get(aAddon.id).syncWithDB(aAddon);
+    lazy.XPIInternal.XPIStates.save();
+
+    Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
+
+    if (!aAddon.disabled) {
+      lazy.XPIInternal.BootstrapScope.get(aAddon).startup(
+        lazy.XPIInternal.BOOTSTRAP_REASONS.ADDON_INSTALL
+      );
+      lazy.XPIDatabase.updateAddonActive(aAddon, true);
+    }
+
+    let wrapper = aAddon.wrapper;
+    AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
+
+    // Notify any other providers that this theme is now enabled again.
+    if (aAddon.type === "theme" && aAddon.active) {
+      AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, false);
+    }
+  },
+
+  DirectoryInstaller,
+  SystemAddonInstaller,
+};