--- a/toolkit/mozapps/extensions/internal/XPIInstall.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
@@ -2283,43 +2283,42 @@ var DownloadAddonInstall = class extends
     } else
       logger.debug("downloadFailed: listener changed AddonInstall state for " +
           this.sourceURI.spec + " to " + this.state);
   }
 
   /**
    * Notify listeners that the download completed.
    */
-  downloadCompleted() {
-    XPIDatabase.getVisibleAddonForID(this.addon.id, aAddon => {
-      if (aAddon)
-        this.existingAddon = aAddon;
+  async downloadCompleted() {
+    let aAddon = await XPIDatabase.getVisibleAddonForID(this.addon.id);
+    if (aAddon)
+      this.existingAddon = aAddon;
 
-      this.state = AddonManager.STATE_DOWNLOADED;
-      this.addon.updateDate = Date.now();
+    this.state = AddonManager.STATE_DOWNLOADED;
+    this.addon.updateDate = Date.now();
 
-      if (this.existingAddon) {
-        this.addon.existingAddonID = this.existingAddon.id;
-        this.addon.installDate = this.existingAddon.installDate;
-      } else {
-        this.addon.installDate = this.addon.updateDate;
-      }
-      this.addon.updateBlocklistState({oldAddon: this.existingAddon});
+    if (this.existingAddon) {
+      this.addon.existingAddonID = this.existingAddon.id;
+      this.addon.installDate = this.existingAddon.installDate;
+    } else {
+      this.addon.installDate = this.addon.updateDate;
+    }
+    this.addon.updateBlocklistState({oldAddon: this.existingAddon});
 
-      if (AddonManagerPrivate.callInstallListeners("onDownloadEnded",
-                                                   this.listeners,
-                                                   this.wrapper)) {
-        // If a listener changed our state then do not proceed with the install
-        if (this.state != AddonManager.STATE_DOWNLOADED)
-          return;
+    if (AddonManagerPrivate.callInstallListeners("onDownloadEnded",
+                                                 this.listeners,
+                                                 this.wrapper)) {
+      // If a listener changed our state then do not proceed with the install
+      if (this.state != AddonManager.STATE_DOWNLOADED)
+        return;
 
-        // proceed with the install state machine.
-        this.install();
-      }
-    });
+      // 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;
       }

--- a/toolkit/mozapps/extensions/internal/XPIProvider.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIProvider.jsm
@@ -3415,40 +3415,38 @@ var XPIProvider = {
   /**
    * Called to get an Addon with a particular ID.
    *
    * @param  aId
    *         The ID of the add-on to retrieve
    * @param  aCallback
    *         A callback to pass the Addon to
    */
-  getAddonByID(aId, aCallback) {
-    XPIDatabase.getVisibleAddonForID(aId, function(aAddon) {
-      aCallback(aAddon ? aAddon.wrapper : null);
-    });
+  async getAddonByID(aId, aCallback) {
+    let aAddon = await XPIDatabase.getVisibleAddonForID(aId);
+    aCallback(aAddon ? aAddon.wrapper : null);
   },
 
   /**
    * Called to get Addons of a particular type.
    *
    * @param  aTypes
    *         An array of types to fetch. Can be null to get all types.
    * @param  aCallback
    *         A callback to pass an array of Addons to
    */
-  getAddonsByTypes(aTypes, aCallback) {
+  async getAddonsByTypes(aTypes, aCallback) {
     let typesToGet = getAllAliasesForTypes(aTypes);
     if (typesToGet && !typesToGet.some(type => ALL_EXTERNAL_TYPES.has(type))) {
       aCallback([]);
       return;
     }
 
-    XPIDatabase.getVisibleAddons(typesToGet, function(aAddons) {
-      aCallback(aAddons.map(a => a.wrapper));
-    });
+    let aAddons = await XPIDatabase.getVisibleAddons(typesToGet);
+    aCallback(aAddons.map(a => a.wrapper));
   },
 
   /**
    * Called to get active Addons of a particular type
    *
    * @param  aTypes
    *         An array of types to fetch. Can be null to get all types.
    * @returns {Promise<Array<Addon>>}
@@ -3500,42 +3498,40 @@ var XPIProvider = {
   /**
    * Obtain an Addon having the specified Sync GUID.
    *
    * @param  aGUID
    *         String GUID of add-on to retrieve
    * @param  aCallback
    *         A callback to pass the Addon to. Receives null if not found.
    */
-  getAddonBySyncGUID(aGUID, aCallback) {
-    XPIDatabase.getAddonBySyncGUID(aGUID, function(aAddon) {
-      aCallback(aAddon ? aAddon.wrapper : null);
-    });
+  async getAddonBySyncGUID(aGUID, aCallback) {
+    let aAddon = await XPIDatabase.getAddonBySyncGUID(aGUID);
+    aCallback(aAddon ? aAddon.wrapper : null);
   },
 
   /**
    * Called to get Addons that have pending operations.
    *
    * @param  aTypes
    *         An array of types to fetch. Can be null to get all types
    * @param  aCallback
    *         A callback to pass an array of Addons to
    */
-  getAddonsWithOperationsByTypes(aTypes, aCallback) {
+  async getAddonsWithOperationsByTypes(aTypes, aCallback) {
     let typesToGet = getAllAliasesForTypes(aTypes);
 
-    XPIDatabase.getVisibleAddonsWithPendingOperations(typesToGet, function(aAddons) {
-      let results = aAddons.map(a => a.wrapper);
-      for (let install of XPIProvider.installs) {
-        if (install.state == AddonManager.STATE_INSTALLED &&
-            !(install.addon.inDatabase))
-          results.push(install.addon.wrapper);
-      }
-      aCallback(results);
-    });
+    let aAddons = await XPIDatabase.getVisibleAddonsWithPendingOperations(typesToGet);
+    let results = aAddons.map(a => a.wrapper);
+    for (let install of XPIProvider.installs) {
+      if (install.state == AddonManager.STATE_INSTALLED &&
+          !(install.addon.inDatabase))
+        results.push(install.addon.wrapper);
+    }
+    aCallback(results);
   },
 
   /**
    * Called to get the current AddonInstalls, optionally limiting to a list of
    * types.
    *
    * @param  aTypes
    *         An array of types or null to get all types
@@ -3588,42 +3584,41 @@ var XPIProvider = {
   },
 
   /**
    * Update the repositoryAddon property for all add-ons.
    *
    * @param  aCallback
    *         Function to call when operation is complete.
    */
-  updateAddonRepositoryData(aCallback) {
-    XPIDatabase.getVisibleAddons(null, aAddons => {
-      let pending = aAddons.length;
-      logger.debug("updateAddonRepositoryData found " + pending + " visible add-ons");
-      if (pending == 0) {
+  async updateAddonRepositoryData(aCallback) {
+    let aAddons = await XPIDatabase.getVisibleAddons(null);
+    let pending = aAddons.length;
+    logger.debug("updateAddonRepositoryData found " + pending + " visible add-ons");
+    if (pending == 0) {
+      aCallback();
+      return;
+    }
+
+    function notifyComplete() {
+      if (--pending == 0)
         aCallback();
-        return;
-      }
-
-      function notifyComplete() {
-        if (--pending == 0)
-          aCallback();
-      }
-
-      for (let addon of aAddons) {
-        AddonRepository.getCachedAddonByID(addon.id).then(aRepoAddon => {
-          if (aRepoAddon || AddonRepository.getCompatibilityOverridesSync(addon.id)) {
-            logger.debug("updateAddonRepositoryData got info for " + addon.id);
-            addon._repositoryAddon = aRepoAddon;
-            this.updateAddonDisabledState(addon);
-          }
-
-          notifyComplete();
-        });
-      }
-    });
+    }
+
+    for (let addon of aAddons) {
+      AddonRepository.getCachedAddonByID(addon.id).then(aRepoAddon => {
+        if (aRepoAddon || AddonRepository.getCompatibilityOverridesSync(addon.id)) {
+          logger.debug("updateAddonRepositoryData got info for " + addon.id);
+          addon._repositoryAddon = aRepoAddon;
+          this.updateAddonDisabledState(addon);
+        }
+
+        notifyComplete();
+      });
+    }
   },
 
   onDebugConnectionChange({what, connection}) {
     if (what != "opened")
       return;
 
     for (let [id, val] of this.activeAddons) {
       connection.setAddonOptions(
@@ -4050,17 +4045,17 @@ var XPIProvider = {
    *         The DBAddonInternal to uninstall
    * @param  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
    */
-  uninstallAddon(aAddon, aForcePending) {
+  async uninstallAddon(aAddon, aForcePending) {
     if (!(aAddon.inDatabase))
       throw new Error("Cannot uninstall addon " + aAddon.id + " because it is not installed");
 
     if (aAddon._installLocation.locked)
       throw new Error("Cannot uninstall addon " + aAddon.id
           + " from locked install location " + aAddon._installLocation.name);
 
     if (aForcePending && aAddon.pendingUninstall)
@@ -4136,41 +4131,40 @@ var XPIProvider = {
         XPIInstall.flushChromeCaches();
       }
       aAddon._installLocation.uninstallAddon(aAddon.id);
       XPIDatabase.removeAddonMetadata(aAddon);
       XPIStates.removeAddon(aAddon.location, aAddon.id);
       AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);
 
       if (existingAddon) {
-        XPIDatabase.getAddonInLocation(aAddon.id, existingAddon.location.name, existing => {
-          XPIDatabase.makeAddonVisible(existing);
-
-          let wrappedAddon = existing.wrapper;
-          AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false);
-
-          if (!existing.disabled) {
-            XPIDatabase.updateAddonActive(existing, true);
-          }
-
-          if (aAddon.bootstrap) {
-            let method = callUpdate ? "update" : "install";
+        let existing = await XPIDatabase.getAddonInLocation(aAddon.id, existingAddon.location.name);
+        XPIDatabase.makeAddonVisible(existing);
+
+        let wrappedAddon = existing.wrapper;
+        AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false);
+
+        if (!existing.disabled) {
+          XPIDatabase.updateAddonActive(existing, true);
+        }
+
+        if (aAddon.bootstrap) {
+          let method = callUpdate ? "update" : "install";
+          XPIProvider.callBootstrapMethod(existing, existing._sourceBundle,
+                                          method, reason);
+
+          if (existing.active) {
             XPIProvider.callBootstrapMethod(existing, existing._sourceBundle,
-                                            method, reason);
-
-            if (existing.active) {
-              XPIProvider.callBootstrapMethod(existing, existing._sourceBundle,
-                                              "startup", reason);
-            } else {
-              XPIProvider.unloadBootstrapScope(existing.id);
-            }
+                                            "startup", reason);
+          } else {
+            XPIProvider.unloadBootstrapScope(existing.id);
           }
-
-          AddonManagerPrivate.callAddonListeners("onInstalled", wrappedAddon);
-        });
+        }
+
+        AddonManagerPrivate.callAddonListeners("onInstalled", wrappedAddon);
       }
     } else if (aAddon.bootstrap && aAddon.active) {
       this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown", reason);
       XPIStates.disableAddon(aAddon.id);
       this.unloadBootstrapScope(aAddon.id);
       XPIDatabase.updateAddonActive(aAddon, false);
     }