--- a/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
@@ -74,16 +74,17 @@ XPCOMUtils.defineLazyServiceGetter(this,
 const {
   awaitPromise,
   createAppInfo,
   createHttpServer,
   createInstallRDF,
   createTempWebExtensionFile,
   createUpdateRDF,
   getFileForAddon,
+  manuallyInstall,
   manuallyUninstall,
   overrideBuiltIns,
   promiseAddonEvent,
   promiseCompleteAllInstalls,
   promiseCompleteInstall,
   promiseConsoleOutput,
   promiseFindAddonUpdates,
   promiseInstallAllFiles,
@@ -94,21 +95,16 @@ const {
   promiseStartupManager,
   promiseWebExtensionStartup,
   promiseWriteProxyFileToDir,
   registerDirectory,
   setExtensionModifiedTime,
   writeFilesToZip
 } = AddonTestUtils;
 
-function manuallyInstall(...args) {
-  return AddonTestUtils.awaitPromise(
-    AddonTestUtils.manuallyInstall(...args));
-}
-
 // WebExtension wrapper for ease of testing
 ExtensionTestUtils.init(this);
 
 AddonTestUtils.init(this);
 AddonTestUtils.overrideCertDB();
 
 Object.defineProperty(this, "gAppInfo", {
   get() {
@@ -1505,31 +1501,31 @@ async function getSystemAddonDirectories
  */
 async function setupSystemAddonConditions(setup, distroDir) {
   info("Clearing existing database.");
   Services.prefs.clearUserPref(PREF_SYSTEM_ADDON_SET);
   distroDir.leafName = "empty";
 
   let updateList = [];
   awaitPromise(overrideBuiltIns({ "system": updateList }));
-  startupManager();
+  await promiseStartupManager();
   await promiseShutdownManager();
 
   info("Setting up conditions.");
   await setup.setup();
 
   if (distroDir) {
     if (distroDir.path.endsWith("hidden")) {
       updateList = ["system1@tests.mozilla.org", "system2@tests.mozilla.org"];
     } else if (distroDir.path.endsWith("prefilled")) {
       updateList = ["system2@tests.mozilla.org", "system3@tests.mozilla.org"];
     }
   }
   awaitPromise(overrideBuiltIns({ "system": updateList }));
-  startupManager();
+  await promiseStartupManager();
 
   // Make sure the initial state is correct
   info("Checking initial state.");
   await checkInstalledSystemAddons(setup.initialState, distroDir);
 }
 
 /**
  * Verify state of system add-ons after installation.
@@ -1576,17 +1572,17 @@ async function verifySystemAddonState(in
   if (distroDir) {
     if (distroDir.path.endsWith("hidden")) {
       updateList = ["system1@tests.mozilla.org", "system2@tests.mozilla.org"];
     } else if (distroDir.path.endsWith("prefilled")) {
       updateList = ["system2@tests.mozilla.org", "system3@tests.mozilla.org"];
     }
   }
   awaitPromise(overrideBuiltIns({ "system": updateList }));
-  startupManager();
+  await promiseStartupManager();
   await checkInstalledSystemAddons(finalState, distroDir);
 }
 
 /**
  * Run system add-on tests and compare the results against a set of expected conditions.
  *
  * @param {String} setupName - name of the current setup conditions.
  * @param {Object<function, Array<Object>} setup -  Defines the set of initial conditions to run each test against. Each should

--- a/toolkit/mozapps/extensions/test/xpcshell/test_AddonRepository_cache.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_AddonRepository_cache.js
@@ -484,17 +484,17 @@ async function check_initialized_cache(a
   let cacheEnabled = Services.prefs.getBoolPref(PREF_GETADDONS_CACHE_ENABLED);
   await check_cache(aExpectedToFind, !cacheEnabled);
 }
 
 add_task(async function setup() {
   // Setup for test
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9");
 
-  startupManager();
+  await promiseStartupManager();
 
   // Install XPI add-ons
   await promiseInstallAllFiles(ADDON_FILES);
   await promiseRestartManager();
 
   gServer = AddonTestUtils.createHttpServer({hosts: [HOST]});
   gServer.registerDirectory("/data/", do_get_file("data"));
 });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_LightweightThemeManager.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_LightweightThemeManager.js
@@ -18,19 +18,19 @@ function dummy(id) {
   };
 }
 
 function hasPermission(aAddon, aPerm) {
   var perm = AddonManager["PERM_CAN_" + aPerm.toUpperCase()];
   return !!(aAddon.permissions & perm);
 }
 
-async function run_test() {
+add_task(async function run_test() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9");
-  startupManager();
+  await promiseStartupManager();
 
   Services.prefs.setIntPref("lightweightThemes.maxUsedThemes", 8);
 
   let {LightweightThemeManager: ltm} = ChromeUtils.import("resource://gre/modules/LightweightThemeManager.jsm", {});
 
   Assert.equal(typeof ltm, "object");
   Assert.equal(typeof ltm.usedThemes, "object");
   Assert.equal(ltm.usedThemes.length, 1);
@@ -529,18 +529,16 @@ async function run_test() {
   Assert.equal([...ltm._builtInThemes].length, 0);
   Assert.equal(ltm.usedThemes.length, 0);
 
   ltm.addBuiltInTheme(dummy("builtInTheme0"));
   ltm.addBuiltInTheme(dummy("builtInTheme1"));
   Assert.equal([...ltm._builtInThemes].length, 2);
   Assert.equal(ltm.usedThemes.length, 2);
 
-  do_test_pending();
-
   let builtInThemeAddon = await AddonManager.getAddonByID("builtInTheme0@personas.mozilla.org");
   Assert.equal(hasPermission(builtInThemeAddon, "uninstall"), false);
   Assert.equal(hasPermission(builtInThemeAddon, "disable"), false);
   Assert.equal(hasPermission(builtInThemeAddon, "enable"), true);
 
   ltm.currentTheme = dummy("x0");
   Assert.equal([...ltm._builtInThemes].length, 2);
   Assert.equal(ltm.usedThemes.length, 3);
@@ -572,11 +570,9 @@ async function run_test() {
   Assert.equal(ltm.usedThemes.length, 1);
 
   Assert.ok(ltm.forgetBuiltInTheme("builtInTheme1"));
   Assert.ok(!ltm.forgetBuiltInTheme("not-an-existing-theme-id"));
 
   Assert.equal([...ltm._builtInThemes].length, 0);
   Assert.equal(ltm.usedThemes.length, 0);
   Assert.equal(ltm.currentTheme, null);
-
-  do_test_finished();
-}
+});

--- a/toolkit/mozapps/extensions/test/xpcshell/test_XPIStates.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_XPIStates.js
@@ -17,69 +17,71 @@ function run_test() {
   // Shut down the add-on manager after all tests run.
   registerCleanupFunction(promiseShutdownManager);
   // Kick off the task-based tests...
   run_next_test();
 }
 
 // Use bootstrap extensions so the changes will be immediate.
 // A packed extension, to be enabled
-writeInstallRDFToXPI({
-  id: "packed-enabled@tests.mozilla.org",
-  version: "1.0",
-  bootstrap: true,
-  targetApplications: [{
-    id: "xpcshell@tests.mozilla.org",
-    minVersion: "1",
-    maxVersion: "1"
-  }],
-  name: "Packed, Enabled",
-}, profileDir);
+add_task(async function setup() {
+  await promiseWriteInstallRDFToXPI({
+    id: "packed-enabled@tests.mozilla.org",
+    version: "1.0",
+    bootstrap: true,
+    targetApplications: [{
+      id: "xpcshell@tests.mozilla.org",
+      minVersion: "1",
+      maxVersion: "1"
+    }],
+    name: "Packed, Enabled",
+  }, profileDir);
 
-// Packed, will be disabled
-writeInstallRDFToXPI({
-  id: "packed-disabled@tests.mozilla.org",
-  version: "1.0",
-  bootstrap: true,
-  targetApplications: [{
-    id: "xpcshell@tests.mozilla.org",
-    minVersion: "1",
-    maxVersion: "1"
-  }],
-  name: "Packed, Disabled",
-}, profileDir);
+  // Packed, will be disabled
+  await promiseWriteInstallRDFToXPI({
+    id: "packed-disabled@tests.mozilla.org",
+    version: "1.0",
+    bootstrap: true,
+    targetApplications: [{
+      id: "xpcshell@tests.mozilla.org",
+      minVersion: "1",
+      maxVersion: "1"
+    }],
+    name: "Packed, Disabled",
+  }, profileDir);
 
-// Unpacked, enabled
-writeInstallRDFToDir({
-  id: "unpacked-enabled@tests.mozilla.org",
-  version: "1.0",
-  bootstrap: true,
-  unpack: true,
-  targetApplications: [{
-    id: "xpcshell@tests.mozilla.org",
-    minVersion: "1",
-    maxVersion: "1"
-  }],
-  name: "Unpacked, Enabled",
-}, profileDir, undefined, "extraFile.js");
+  // Unpacked, enabled
+  await promiseWriteInstallRDFToDir({
+    id: "unpacked-enabled@tests.mozilla.org",
+    version: "1.0",
+    bootstrap: true,
+    unpack: true,
+    targetApplications: [{
+      id: "xpcshell@tests.mozilla.org",
+      minVersion: "1",
+      maxVersion: "1"
+    }],
+    name: "Unpacked, Enabled",
+  }, profileDir, undefined, "extraFile.js");
 
 
-// Unpacked, disabled
-writeInstallRDFToDir({
-  id: "unpacked-disabled@tests.mozilla.org",
-  version: "1.0",
-  bootstrap: true,
-  unpack: true,
-  targetApplications: [{
-    id: "xpcshell@tests.mozilla.org",
-    minVersion: "1",
-    maxVersion: "1"
-  }],
-  name: "Unpacked, disabled",
-}, profileDir, undefined, "extraFile.js");
+  // Unpacked, disabled
+  await promiseWriteInstallRDFToDir({
+    id: "unpacked-disabled@tests.mozilla.org",
+    version: "1.0",
+    bootstrap: true,
+    unpack: true,
+    targetApplications: [{
+      id: "xpcshell@tests.mozilla.org",
+      minVersion: "1",
+      maxVersion: "1"
+    }],
+    name: "Unpacked, disabled",
+  }, profileDir, undefined, "extraFile.js");
+});
 
 // Keep track of the last time stamp we've used, so that we can keep moving
 // it forward (if we touch two different files in the same add-on with the same
 // timestamp we may not consider the change significant)
 var lastTimestamp = Date.now();
 
 /*
  * Helper function to touch a file and then test whether we detect the change.
@@ -105,17 +107,17 @@ function getXS() {
 
 async function getXSJSON() {
   await AddonTestUtils.loadAddonsList(true);
 
   return aomStartup.readStartupData();
 }
 
 add_task(async function detect_touches() {
-  startupManager();
+  await promiseStartupManager();
   let [/* pe */, pd, /* ue */, ud] = await promiseAddonsByIDs([
          "packed-enabled@tests.mozilla.org",
          "packed-disabled@tests.mozilla.org",
          "unpacked-enabled@tests.mozilla.org",
          "unpacked-disabled@tests.mozilla.org"
          ]);
 
   info("Disable test add-ons");

--- a/toolkit/mozapps/extensions/test/xpcshell/test_backgroundupdate.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_backgroundupdate.js
@@ -6,27 +6,27 @@
 
 // The test extension uses an insecure update url.
 Services.prefs.setBoolPref(PREF_EM_CHECK_UPDATE_SECURITY, false);
 
 var testserver = AddonTestUtils.createHttpServer({hosts: ["example.com"]});
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
-function run_test() {
+add_task(async function setup() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
   testserver.registerDirectory("/addons/", do_get_file("addons"));
   testserver.registerDirectory("/data/", do_get_file("data"));
 
-  startupManager();
+  await promiseStartupManager();
 
   do_test_pending();
   run_test_1();
-}
+});
 
 function end_test() {
   do_test_finished();
 }
 
 // Verify that with no add-ons installed the background update notifications get
 // called
 async function run_test_1() {
@@ -40,44 +40,44 @@ async function run_test_1() {
   }, "addons-background-update-complete");
 
   // Trigger the background update timer handler
   gInternalManager.notify(null);
 }
 
 // Verify that with two add-ons installed both of which claim to have updates
 // available we get the notification after both updates attempted to start
-function run_test_2() {
-  writeInstallRDFForExtension({
+async function run_test_2() {
+  await promiseWriteInstallRDFForExtension({
     id: "addon1@tests.mozilla.org",
     version: "1.0",
     updateURL: "http://example.com/data/test_backgroundupdate.json",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "1"
     }],
     name: "Test Addon 1",
   }, profileDir);
 
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "addon2@tests.mozilla.org",
     version: "1.0",
     updateURL: "http://example.com/data/test_backgroundupdate.json",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "1"
     }],
     name: "Test Addon 2",
   }, profileDir);
 
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "addon3@tests.mozilla.org",
     version: "1.0",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "1"
     }],
@@ -86,17 +86,17 @@ function run_test_2() {
 
   // Disable rcwn to make cache behavior deterministic.
   Services.prefs.setBoolPref("network.http.rcwn.enabled", false);
 
   // Background update uses a different pref, if set
   Services.prefs.setCharPref("extensions.update.background.url",
                              "http://example.com/data/test_backgroundupdate.json");
 
-  restartManager();
+  await promiseRestartManager();
 
   let installCount = 0;
   let completeCount = 0;
   let sawCompleteNotification = false;
 
   Services.obs.addObserver(function observer() {
     Services.obs.removeObserver(observer, "addons-background-update-complete");
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_bad_json.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_bad_json.js
@@ -19,17 +19,17 @@ var addon1 = {
 
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
 add_task(async function() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
   // This addon will be auto-installed at startup
-  writeInstallRDFForExtension(addon1, profileDir);
+  await promiseWriteInstallRDFForExtension(addon1, profileDir);
 
   await promiseStartupManager();
   await promiseShutdownManager();
 
   // First startup/shutdown finished
   // Replace the JSON store with something bogus
   await saveJSON({not: "what we expect to find"}, gExtensionsJSON.path);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_metadata_filters.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_metadata_filters.js
@@ -66,76 +66,76 @@ function end_test() {
 }
 
 async function run_test() {
   do_test_pending();
 
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
 
   // Should get blocked by name
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block1@tests.mozilla.org",
     version: "1.0",
     name: "Mozilla Corp.",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
     }]
   }, profileDir);
 
   // Should get blocked by all the attributes.
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block2@tests.mozilla.org",
     version: "1.0",
     name: "Moz-addon",
     bootstrap: true,
     creator: "Dangerous",
     homepageURL: "www.extension.dangerous.com",
     updateURL: "www.extension.dangerous.com/update.rdf",
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
     }]
   }, profileDir);
 
   // Fails to get blocked because of a different ID even though other
   // attributes match against a blocklist entry.
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block3@tests.mozilla.org",
     version: "1.0",
     name: "Moz-addon",
     bootstrap: true,
     creator: "Dangerous",
     homepageURL: "www.extensions.dangerous.com",
     updateURL: "www.extension.dangerous.com/update.rdf",
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
     }]
   }, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [a1, a2, a3] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org",
                                                         "block2@tests.mozilla.org",
                                                         "block3@tests.mozilla.org"]);
   Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   Assert.equal(a2.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   Assert.equal(a3.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
 
   run_test_1();
 }
 
 function run_test_1() {
   load_blocklist("test_blocklist_metadata_filters_1.xml", async function() {
-    restartManager();
+    await promiseRestartManager();
 
     let [a1, a2, a3] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org",
                                                           "block2@tests.mozilla.org",
                                                           "block3@tests.mozilla.org"]);
     Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
     Assert.equal(a2.blocklistState, Ci.nsIBlocklistService.STATE_BLOCKED);
     Assert.equal(a3.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
     end_test();

--- a/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_prefs.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_prefs.js
@@ -66,29 +66,29 @@ function end_test() {
 }
 
 async function run_test() {
   do_test_pending();
 
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
 
   // Add 2 extensions
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block1@tests.mozilla.org",
     version: "1.0",
     name: "Blocked add-on-1 with to-be-reset prefs",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
     }]
   }, profileDir);
 
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block2@tests.mozilla.org",
     version: "1.0",
     name: "Blocked add-on-2 with to-be-reset prefs",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
@@ -96,34 +96,34 @@ async function run_test() {
   }, profileDir);
 
   // Pre-set the preferences that we expect to get reset.
   Services.prefs.setIntPref("test.blocklist.pref1", 15);
   Services.prefs.setIntPref("test.blocklist.pref2", 15);
   Services.prefs.setBoolPref("test.blocklist.pref3", true);
   Services.prefs.setBoolPref("test.blocklist.pref4", true);
 
-  startupManager();
+  await promiseStartupManager();
 
   // Before blocklist is loaded.
   let [a1, a2] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org",
                                                     "block2@tests.mozilla.org"]);
   Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   Assert.equal(a2.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
 
   Assert.equal(Services.prefs.getIntPref("test.blocklist.pref1"), 15);
   Assert.equal(Services.prefs.getIntPref("test.blocklist.pref2"), 15);
   Assert.equal(Services.prefs.getBoolPref("test.blocklist.pref3"), true);
   Assert.equal(Services.prefs.getBoolPref("test.blocklist.pref4"), true);
   run_test_1();
 }
 
 function run_test_1() {
   load_blocklist("test_blocklist_prefs_1.xml", async function() {
-    restartManager();
+    await promiseRestartManager();
 
     // Blocklist changes should have applied and the prefs must be reset.
     let [a1, a2] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org",
                                                       "block2@tests.mozilla.org"]);
     Assert.notEqual(a1, null);
     Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
     Assert.notEqual(a2, null);
     Assert.equal(a2.blocklistState, Ci.nsIBlocklistService.STATE_BLOCKED);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_regexp.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_blocklist_regexp.js
@@ -70,39 +70,39 @@ function end_test() {
 }
 
 
 async function run_test() {
   do_test_pending();
 
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
 
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "block1@tests.mozilla.org",
     version: "1.0",
     name: "RegExp blocked add-on",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "3"
     }]
   }, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [a1] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org"]);
   Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
 
   run_test_1();
 }
 
 function run_test_1() {
   load_blocklist("test_blocklist_regexp_1.xml", async function() {
-    restartManager();
+    await promiseRestartManager();
 
     let [a1] = await AddonManager.getAddonsByIDs(["block1@tests.mozilla.org"]);
     Assert.notEqual(a1, null);
     Assert.equal(a1.blocklistState, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
 
     end_test();
   });
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_blocklistchange.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_blocklistchange.js
@@ -698,23 +698,23 @@ function check_addon(aAddon, aExpectedVe
 }
 
 function run_test() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
   run_next_test();
 }
 
 add_task(async function init() {
-  writeInstallRDFForExtension(softblock1_1, profileDir);
-  writeInstallRDFForExtension(softblock2_1, profileDir);
-  writeInstallRDFForExtension(softblock3_1, profileDir);
-  writeInstallRDFForExtension(softblock4_1, profileDir);
-  writeInstallRDFForExtension(hardblock_1, profileDir);
-  writeInstallRDFForExtension(regexpblock_1, profileDir);
-  startupManager();
+  await promiseWriteInstallRDFForExtension(softblock1_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_1, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_1, profileDir);
+  await promiseStartupManager();
 
   let [/* s1 */, /* s2 */, /* s3 */, s4, /* h, r */] = await promiseAddonsByIDs(ADDON_IDS);
   s4.userDisabled = true;
 });
 
 // Starts with add-ons unblocked and then switches application versions to
 // change add-ons to blocked and back
 add_task(async function run_app_update_test() {
@@ -838,17 +838,17 @@ add_task(async function update_schema_3(
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "1.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
 });
 
 add_task(async function update_schema_4() {
   await promiseShutdownManager();
 
   await changeXPIDBVersion(100);
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "1.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "1.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "1.0", false, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s4, "1.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
@@ -952,30 +952,30 @@ add_task(async function run_addon_change
   check_addon(s4, "1.0", true, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(r, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
 });
 
 add_task(async function run_addon_change_2() {
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock1_2.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock2_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock2_2.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock3_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock3_2.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock4_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock4_2.id), Date.now() + 10000);
-  writeInstallRDFForExtension(hardblock_2, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, hardblock_2.id), Date.now() + 10000);
-  writeInstallRDFForExtension(regexpblock_2, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_2, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, regexpblock_2.id), Date.now() + 10000);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s4, "2.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "2.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
@@ -988,58 +988,58 @@ add_task(async function run_addon_change
   check_addon(s3, "2.0", false, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
 });
 
 add_task(async function run_addon_change_3() {
   await promiseRestartManager();
 
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock1_3.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock2_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock2_3.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock3_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock3_3.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock4_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock4_3.id), Date.now() + 20000);
-  writeInstallRDFForExtension(hardblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, hardblock_3.id), Date.now() + 20000);
-  writeInstallRDFForExtension(regexpblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, regexpblock_3.id), Date.now() + 20000);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "3.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "3.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "3.0", false, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s4, "3.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
 });
 
 add_task(async function run_addon_change_4() {
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock1_1.id), Date.now() + 30000);
-  writeInstallRDFForExtension(softblock2_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock2_1.id), Date.now() + 30000);
-  writeInstallRDFForExtension(softblock3_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock3_1.id), Date.now() + 30000);
-  writeInstallRDFForExtension(softblock4_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock4_1.id), Date.now() + 30000);
-  writeInstallRDFForExtension(hardblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, hardblock_1.id), Date.now() + 30000);
-  writeInstallRDFForExtension(regexpblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, regexpblock_1.id), Date.now() + 30000);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(s2, "1.0", true, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(s3, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(s4, "1.0", true, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
@@ -1059,24 +1059,24 @@ add_task(async function run_addon_change
   getFileForAddon(profileDir, softblock3_1.id).remove(true);
   getFileForAddon(profileDir, softblock4_1.id).remove(true);
   getFileForAddon(profileDir, hardblock_1.id).remove(true);
   getFileForAddon(profileDir, regexpblock_1.id).remove(true);
 
   await promiseStartupManager();
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_2, profileDir);
-  writeInstallRDFForExtension(softblock2_2, profileDir);
-  writeInstallRDFForExtension(softblock3_2, profileDir);
-  writeInstallRDFForExtension(softblock4_2, profileDir);
-  writeInstallRDFForExtension(hardblock_2, profileDir);
-  writeInstallRDFForExtension(regexpblock_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_2, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_2, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_2, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_2, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, /* s4 */, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "2.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "2.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "2.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
@@ -1088,57 +1088,57 @@ add_task(async function run_addon_change
   check_addon(s3, "2.0", false, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
 });
 
 add_task(async function addon_change_2_test_2() {
   await promiseRestartManager();
 
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock1_3.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock2_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock2_3.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock3_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock3_3.id), Date.now() + 10000);
-  writeInstallRDFForExtension(softblock4_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock4_3.id), Date.now() + 10000);
-  writeInstallRDFForExtension(hardblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, hardblock_3.id), Date.now() + 10000);
-  writeInstallRDFForExtension(regexpblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_3, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, regexpblock_3.id), Date.now() + 10000);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, /* s4 */, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "3.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "3.0", true, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "3.0", false, false, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
 });
 
 add_task(async function addon_change_2_test_3() {
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock1_1.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock2_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock2_1.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock3_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock3_1.id), Date.now() + 20000);
-  writeInstallRDFForExtension(softblock4_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, softblock4_1.id), Date.now() + 20000);
-  writeInstallRDFForExtension(hardblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, hardblock_1.id), Date.now() + 20000);
-  writeInstallRDFForExtension(regexpblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_1, profileDir);
   setExtensionModifiedTime(getFileForAddon(profileDir, regexpblock_1.id), Date.now() + 20000);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(s2, "1.0", true, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(s3, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
   check_addon(r, "1.0", false, false, Ci.nsIBlocklistService.STATE_NOT_BLOCKED);
@@ -1185,24 +1185,24 @@ add_task(async function run_background_u
   getFileForAddon(profileDir, softblock3_1.id).remove(true);
   getFileForAddon(profileDir, softblock4_1.id).remove(true);
   getFileForAddon(profileDir, hardblock_1.id).remove(true);
   getFileForAddon(profileDir, regexpblock_1.id).remove(true);
 
   await promiseStartupManager();
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_3, profileDir);
-  writeInstallRDFForExtension(softblock2_3, profileDir);
-  writeInstallRDFForExtension(softblock3_3, profileDir);
-  writeInstallRDFForExtension(softblock4_3, profileDir);
-  writeInstallRDFForExtension(hardblock_3, profileDir);
-  writeInstallRDFForExtension(regexpblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_3, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_3, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_3, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_3, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "3.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "3.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "3.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "3.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
@@ -1291,24 +1291,24 @@ add_task(async function run_manual_updat
   getFileForAddon(profileDir, softblock3_1.id).remove(true);
   getFileForAddon(profileDir, softblock4_1.id).remove(true);
   getFileForAddon(profileDir, hardblock_1.id).remove(true);
   getFileForAddon(profileDir, regexpblock_1.id).remove(true);
 
   await promiseStartupManager();
   await promiseShutdownManager();
 
-  writeInstallRDFForExtension(softblock1_1, profileDir);
-  writeInstallRDFForExtension(softblock2_1, profileDir);
-  writeInstallRDFForExtension(softblock3_1, profileDir);
-  writeInstallRDFForExtension(softblock4_1, profileDir);
-  writeInstallRDFForExtension(hardblock_1, profileDir);
-  writeInstallRDFForExtension(regexpblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock1_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock2_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock3_1, profileDir);
+  await promiseWriteInstallRDFForExtension(softblock4_1, profileDir);
+  await promiseWriteInstallRDFForExtension(hardblock_1, profileDir);
+  await promiseWriteInstallRDFForExtension(regexpblock_1, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   let [s1, s2, s3, s4, h, r] = await promiseAddonsByIDs(ADDON_IDS);
 
   check_addon(s1, "1.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s2, "1.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(s3, "1.0", true, true, Ci.nsIBlocklistService.STATE_SOFTBLOCKED);
   check_addon(h, "1.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
   check_addon(r, "1.0", false, false, Ci.nsIBlocklistService.STATE_BLOCKED);
@@ -1356,17 +1356,17 @@ add_task(async function run_local_instal
 
   getFileForAddon(profileDir, softblock1_1.id).remove(true);
   getFileForAddon(profileDir, softblock2_1.id).remove(true);
   getFileForAddon(profileDir, softblock3_1.id).remove(true);
   getFileForAddon(profileDir, softblock4_1.id).remove(true);
   getFileForAddon(profileDir, hardblock_1.id).remove(true);
   getFileForAddon(profileDir, regexpblock_1.id).remove(true);
 
-  startupManager();
+  await promiseStartupManager();
 
   await promiseInstallAllFiles([
     XPIS.blocklist_soft1_1,
     XPIS.blocklist_soft2_1,
     XPIS.blocklist_soft3_1,
     XPIS.blocklist_soft4_1,
     XPIS.blocklist_hard1_1,
     XPIS.blocklist_regexp1_1,

--- a/toolkit/mozapps/extensions/test/xpcshell/test_bootstrap.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_bootstrap.js
@@ -497,18 +497,17 @@ add_task(async function test_7() {
   await checkBootstrappedPref();
 });
 
 // Test that a bootstrapped extension dropped into the profile loads properly
 // on startup and doesn't cause an EM restart
 add_task(async function test_8() {
   await promiseShutdownManager();
 
-  manuallyInstall(XPIS.test_bootstrap1_1, profileDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_1, profileDir, ID1);
 
   await promiseStartupManager();
 
   let b1 = await AddonManager.getAddonByID(ID1);
   notEqual(b1, null);
   equal(b1.version, "1.0");
   ok(!b1.appDisabled);
   ok(!b1.userDisabled);
@@ -672,18 +671,17 @@ add_task(async function test_11() {
   await checkBootstrappedPref();
 });
 
 // Tests that bootstrapped extensions are correctly loaded even if the app is
 // upgraded at the same time
 add_task(async function test_12() {
   await promiseShutdownManager();
 
-  manuallyInstall(XPIS.test_bootstrap1_1, profileDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_1, profileDir, ID1);
 
   await promiseStartupManager();
 
   let b1 = await AddonManager.getAddonByID(ID1);
   notEqual(b1, null);
   equal(b1.version, "1.0");
   ok(!b1.appDisabled);
   ok(!b1.userDisabled);
@@ -766,18 +764,17 @@ add_task(async function test_13() {
 
 // Tests that a bootstrapped extension with an invalid target application entry
 // does not get loaded when detected during startup
 add_task(async function test_14() {
   await promiseRestartManager();
 
   await promiseShutdownManager();
 
-  manuallyInstall(XPIS.test_bootstrap1_3, profileDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_3, profileDir, ID1);
 
   await promiseStartupManager();
 
   let b1 = await AddonManager.getAddonByID(ID1);
   notEqual(b1, null);
   equal(b1.version, "3.0");
   ok(b1.appDisabled);
   ok(!b1.userDisabled);
@@ -906,18 +903,17 @@ add_task(async function test_16() {
   let b1_3 = await AddonManager.getAddonByID(ID1);
   b1_3.uninstall();
 });
 
 // Check that a bootstrapped extension in a non-profile location is loaded
 add_task(async function test_17() {
   await promiseShutdownManager();
 
-  manuallyInstall(XPIS.test_bootstrap1_1, userExtDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_1, userExtDir, ID1);
 
   await promiseStartupManager();
 
   let b1 = await AddonManager.getAddonByID(ID1);
   // Should have installed and started
   BootstrapMonitor.checkAddonInstalled(ID1, "1.0");
   BootstrapMonitor.checkAddonStarted(ID1, "1.0");
   notEqual(b1, null);
@@ -997,18 +993,17 @@ add_task(async function test_19() {
   await checkBootstrappedPref();
 });
 
 // Check that a new profile extension detected at startup replaces the non-profile
 // one
 add_task(async function test_20() {
   await promiseShutdownManager();
 
-  manuallyInstall(XPIS.test_bootstrap1_2, profileDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_2, profileDir, ID1);
 
   await promiseStartupManager();
 
   let b1 = await AddonManager.getAddonByID(ID1);
   // Should have installed and started
   BootstrapMonitor.checkAddonInstalled(ID1, "2.0");
   BootstrapMonitor.checkAddonStarted(ID1, "2.0");
   notEqual(b1, null);
@@ -1067,18 +1062,17 @@ add_task(async function test_21() {
 
   await promiseStartupManager();
 });
 
 // Check that an upgrade from the filesystem is detected and applied correctly
 add_task(async function test_22() {
   await promiseShutdownManager();
 
-  let file = manuallyInstall(XPIS.test_bootstrap1_1, profileDir,
-                             ID1);
+  let file = await manuallyInstall(XPIS.test_bootstrap1_1, profileDir, ID1);
   if (file.isDirectory())
     file.append("install.rdf");
 
   // Make it look old so changes are detected
   setExtensionModifiedTime(file, file.lastModifiedTime - 5000);
 
   await promiseStartupManager();
 
@@ -1093,18 +1087,17 @@ add_task(async function test_22() {
 
   await promiseShutdownManager();
 
   equal(getShutdownReason(), APP_SHUTDOWN);
   equal(getShutdownNewVersion(), undefined);
 
   manuallyUninstall(profileDir, ID1);
   BootstrapMonitor.clear(ID1);
-  manuallyInstall(XPIS.test_bootstrap1_2, profileDir,
-                  ID1);
+  await manuallyInstall(XPIS.test_bootstrap1_2, profileDir, ID1);
 
   await promiseStartupManager();
 
   let b1_2 = await AddonManager.getAddonByID(ID1);
   // Should have installed and started
   BootstrapMonitor.checkAddonInstalled(ID1, "2.0");
   BootstrapMonitor.checkAddonStarted(ID1, "2.0");
   notEqual(b1_2, null);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_bootstrap_globals.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_bootstrap_globals.js
@@ -10,27 +10,27 @@ createAppInfo("xpcshell@tests.mozilla.or
 const EXPECTED_GLOBALS = [
   ["Worker", "function"],
   ["ChromeWorker", "function"],
   ["console", "object"]
 ];
 
 async function run_test() {
   do_test_pending();
-  startupManager();
+  await promiseStartupManager();
   let sawGlobals = false;
 
   Services.obs.addObserver(function(subject) {
     subject.wrappedJSObject.expectedGlobals = EXPECTED_GLOBALS;
   }, "bootstrap-request-globals");
 
   Services.obs.addObserver(function({ wrappedJSObject: seenGlobals }) {
     for (let [name, ] of EXPECTED_GLOBALS)
       Assert.ok(seenGlobals.has(name));
 
     sawGlobals = true;
   }, "bootstrap-seen-globals");
 
   await promiseInstallAllFiles([do_get_addon("bootstrap_globals")]);
   Assert.ok(sawGlobals);
-  shutdownManager();
+  await promiseShutdownManager();
   do_test_finished();
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_cache_certdb.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_cache_certdb.js
@@ -11,17 +11,17 @@ profileDir.append("extensions");
 
 const ID = "bootstrap1@tests.mozilla.org";
 
 add_task(async function() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
   AddonTestUtils.manuallyInstall(do_get_addon("test_cache_certdb"), profileDir, ID);
 
-  startupManager();
+  await promiseStartupManager();
 
   // Force a rescan of signatures
   const { XPIProvider } = ChromeUtils.import("resource://gre/modules/addons/XPIProvider.jsm", {});
   await XPIProvider.verifySignatures();
 
   let addon = await AddonManager.getAddonByID(ID);
   Assert.equal(addon.signedState, AddonManager.SIGNEDSTATE_MISSING);
   Assert.ok(!addon.isActive);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_compatoverrides.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_compatoverrides.js
@@ -306,31 +306,31 @@ var addon9 = {
     minVersion: "1",
     maxVersion: "1"
   }]
 };
 
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
-function run_test() {
+async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "2");
 
-  writeInstallRDFForExtension(addon1, profileDir);
-  writeInstallRDFForExtension(addon2, profileDir);
-  writeInstallRDFForExtension(addon3, profileDir);
-  writeInstallRDFForExtension(addon4, profileDir);
-  writeInstallRDFForExtension(addon5, profileDir);
-  writeInstallRDFForExtension(addon6, profileDir);
-  writeInstallRDFForExtension(addon7, profileDir);
-  writeInstallRDFForExtension(addon8, profileDir);
-  writeInstallRDFForExtension(addon9, profileDir);
+  await promiseWriteInstallRDFForExtension(addon1, profileDir);
+  await promiseWriteInstallRDFForExtension(addon2, profileDir);
+  await promiseWriteInstallRDFForExtension(addon3, profileDir);
+  await promiseWriteInstallRDFForExtension(addon4, profileDir);
+  await promiseWriteInstallRDFForExtension(addon5, profileDir);
+  await promiseWriteInstallRDFForExtension(addon6, profileDir);
+  await promiseWriteInstallRDFForExtension(addon7, profileDir);
+  await promiseWriteInstallRDFForExtension(addon8, profileDir);
+  await promiseWriteInstallRDFForExtension(addon9, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   AddonManagerInternal.backgroundUpdateCheck().then(run_test_1);
 }
 
 function end_test() {
   gServer.stop(do_test_finished);
 }
 
@@ -404,13 +404,13 @@ async function check_compat_status(aCall
   executeSoon(aCallback);
 }
 
 function run_test_1() {
   info("Run test 1");
   check_compat_status(run_test_2);
 }
 
-function run_test_2() {
+async function run_test_2() {
   info("Run test 2");
-  restartManager();
+  await promiseRestartManager();
   check_compat_status(end_test);
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_corruptfile.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_corruptfile.js
@@ -2,57 +2,50 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 // Tests that attempting to install a corrupt XPI file doesn't break the universe
 
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
-function run_test() {
+add_task(async function setup() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
 
-  startupManager();
+  await promiseStartupManager();
 
   if (TEST_UNPACKED)
-    run_test_unpacked();
-  else
-    run_test_packed();
-}
+    return run_test_unpacked();
+  return run_test_packed();
+});
 
 // When installing packed we won't detect corruption in the XPI until we attempt
 // to load bootstrap.js so everything will look normal from the outside.
 async function run_test_packed() {
-  do_test_pending();
-
   prepare_test({
     "corrupt@tests.mozilla.org": [
       ["onInstalling", false],
       ["onInstalled", false]
     ]
   }, [
     "onNewInstall",
     "onInstallStarted",
     "onInstallEnded"
   ]);
 
   await promiseInstallAllFiles([do_get_file("data/corruptfile.xpi")]);
   ensure_test_completed();
 
   let addon = await AddonManager.getAddonByID("corrupt@tests.mozilla.org");
   Assert.notEqual(addon, null);
-
-  do_test_finished();
 }
 
 // When extracting the corruption will be detected and the add-on fails to
 // install
 async function run_test_unpacked() {
-  do_test_pending();
-
   prepare_test({
     "corrupt@tests.mozilla.org": [
       ["onInstalling", false],
       "onOperationCancelled"
     ]
   }, [
     "onNewInstall",
     "onInstallStarted",
@@ -69,11 +62,9 @@ async function run_test_unpacked() {
 
   // Check the staging directory isn't left over
   var stageDir = profileDir.clone();
   stageDir.append("staged");
   pathShouldntExist(stageDir);
 
   let addon = await AddonManager.getAddonByID("corrupt@tests.mozilla.org");
   Assert.equal(addon, null);
-
-  do_test_finished();
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_delay_update.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_delay_update.js
@@ -22,18 +22,18 @@ const TEST_IGNORE_PREF = "delaytest.igno
 
 createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "42");
 
 // Create and configure the HTTP server.
 var testserver = AddonTestUtils.createHttpServer({hosts: ["example.com"]});
 testserver.registerDirectory("/data/", do_get_file("data"));
 testserver.registerDirectory("/addons/", do_get_file("addons"));
 
-function createIgnoreAddon() {
-  writeInstallRDFToDir({
+async function createIgnoreAddon() {
+  await promiseWriteInstallRDFToDir({
     id: IGNORE_ID,
     version: "1.0",
     bootstrap: true,
     unpack: true,
     updateURL: `http://example.com/data/test_delay_updates_ignore_legacy.json`,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
@@ -43,18 +43,18 @@ function createIgnoreAddon() {
   }, profileDir, IGNORE_ID, "bootstrap.js");
 
   let unpacked_addon = profileDir.clone();
   unpacked_addon.append(IGNORE_ID);
   do_get_file("data/test_delay_update_ignore/bootstrap.js")
     .copyTo(unpacked_addon, "bootstrap.js");
 }
 
-function createCompleteAddon() {
-  writeInstallRDFToDir({
+async function createCompleteAddon() {
+  await promiseWriteInstallRDFToDir({
     id: COMPLETE_ID,
     version: "1.0",
     bootstrap: true,
     unpack: true,
     updateURL: `http://example.com/data/test_delay_updates_complete_legacy.json`,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
@@ -64,18 +64,18 @@ function createCompleteAddon() {
   }, profileDir, COMPLETE_ID, "bootstrap.js");
 
   let unpacked_addon = profileDir.clone();
   unpacked_addon.append(COMPLETE_ID);
   do_get_file("data/test_delay_update_complete/bootstrap.js")
     .copyTo(unpacked_addon, "bootstrap.js");
 }
 
-function createDeferAddon() {
-  writeInstallRDFToDir({
+async function createDeferAddon() {
+  await promiseWriteInstallRDFToDir({
     id: DEFER_ID,
     version: "1.0",
     bootstrap: true,
     unpack: true,
     updateURL: `http://example.com/data/test_delay_updates_defer_legacy.json`,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
@@ -90,17 +90,17 @@ function createDeferAddon() {
     .copyTo(unpacked_addon, "bootstrap.js");
 }
 
 // add-on registers upgrade listener, and ignores update.
 add_task(async function() {
 
   await createIgnoreAddon();
 
-  startupManager();
+  await promiseStartupManager();
 
   let addon = await promiseAddonByID(IGNORE_ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test Delay Update Ignore");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(addon.isActive);
@@ -131,25 +131,25 @@ add_task(async function() {
   Assert.notEqual(addon_upgraded, null);
   Assert.equal(addon_upgraded.version, "2.0");
   Assert.equal(addon_upgraded.name, "Test Delay Update Ignore");
   Assert.ok(addon_upgraded.isCompatible);
   Assert.ok(!addon_upgraded.appDisabled);
   Assert.ok(addon_upgraded.isActive);
   Assert.equal(addon_upgraded.type, "extension");
 
-  await shutdownManager();
+  await await promiseShutdownManager();
 });
 
 // add-on registers upgrade listener, and allows update.
 add_task(async function() {
 
   await createCompleteAddon();
 
-  startupManager();
+  await promiseStartupManager();
 
   let addon = await promiseAddonByID(COMPLETE_ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test Delay Update Complete");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(addon.isActive);
@@ -187,25 +187,25 @@ add_task(async function() {
   Assert.notEqual(addon_upgraded, null);
   Assert.equal(addon_upgraded.version, "2.0");
   Assert.equal(addon_upgraded.name, "Test Delay Update Complete");
   Assert.ok(addon_upgraded.isCompatible);
   Assert.ok(!addon_upgraded.appDisabled);
   Assert.ok(addon_upgraded.isActive);
   Assert.equal(addon_upgraded.type, "extension");
 
-  await shutdownManager();
+  await await promiseShutdownManager();
 });
 
 // add-on registers upgrade listener, initially defers update then allows upgrade
 add_task(async function() {
 
   await createDeferAddon();
 
-  startupManager();
+  await promiseStartupManager();
 
   let addon = await promiseAddonByID(DEFER_ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test Delay Update Defer");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(addon.isActive);
@@ -246,10 +246,10 @@ add_task(async function() {
   Assert.notEqual(addon_upgraded, null);
   Assert.equal(addon_upgraded.version, "2.0");
   Assert.equal(addon_upgraded.name, "Test Delay Update Defer");
   Assert.ok(addon_upgraded.isCompatible);
   Assert.ok(!addon_upgraded.appDisabled);
   Assert.ok(addon_upgraded.isActive);
   Assert.equal(addon_upgraded.type, "extension");
 
-  await shutdownManager();
+  await await promiseShutdownManager();
 });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_delay_update_webextension.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_delay_update_webextension.js
@@ -34,17 +34,17 @@ const NOUPDATE_ID = "test_no_update_webe
 var testserver = AddonTestUtils.createHttpServer({hosts: ["example.com"]});
 testserver.registerDirectory("/data/", do_get_file("data"));
 testserver.registerDirectory("/addons/", do_get_file("addons"));
 
 createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "42", "42");
 
 // add-on registers upgrade listener, and ignores update.
 add_task(async function delay_updates_ignore() {
-  startupManager();
+  await promiseStartupManager();
 
   let extension = ExtensionTestUtils.loadExtension({
     useAddonManager: "permanent",
     manifest: {
       "version": "1.0",
       "applications": {
         "gecko": {
           "id": IGNORE_ID,
@@ -113,17 +113,17 @@ add_task(async function delay_updates_ig
   Assert.equal(addon_upgraded.type, "extension");
 
   await extension.unload();
   await promiseShutdownManager();
 });
 
 // add-on registers upgrade listener, and allows update.
 add_task(async function delay_updates_complete() {
-  startupManager();
+  await promiseStartupManager();
 
   let extension = ExtensionTestUtils.loadExtension({
     useAddonManager: "permanent",
     manifest: {
       "version": "1.0",
       "applications": {
         "gecko": {
           "id": COMPLETE_ID,
@@ -176,17 +176,17 @@ add_task(async function delay_updates_co
   }
 
   await extension.unload();
   await promiseShutdownManager();
 });
 
 // add-on registers upgrade listener, initially defers update then allows upgrade
 add_task(async function delay_updates_defer() {
-  startupManager();
+  await promiseStartupManager();
 
   let extension = ExtensionTestUtils.loadExtension({
     useAddonManager: "permanent",
     manifest: {
       "version": "1.0",
       "applications": {
         "gecko": {
           "id": DEFER_ID,
@@ -272,17 +272,17 @@ add_task(async function delay_updates_de
   Assert.equal(addon_allowed.type, "extension");
 
   await extension.unload();
   await promiseShutdownManager();
 });
 
 // browser.runtime.reload() without a pending upgrade should just reload.
 add_task(async function runtime_reload() {
-  startupManager();
+  await promiseStartupManager();
 
   let extension = ExtensionTestUtils.loadExtension({
     useAddonManager: "permanent",
     manifest: {
       "version": "1.0",
       "applications": {
         "gecko": {
           "id": NOUPDATE_ID,

--- a/toolkit/mozapps/extensions/test/xpcshell/test_distribution.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_distribution.js
@@ -56,40 +56,40 @@ var addon1_3 = {
 function getActiveVersion() {
   return Services.prefs.getIntPref("bootstraptest.active_version");
 }
 
 function getInstalledVersion() {
   return Services.prefs.getIntPref("bootstraptest.installed_version");
 }
 
-function setOldModificationTime() {
+async function setOldModificationTime() {
   // Make sure the installed extension has an old modification time so any
   // changes will be detected
-  shutdownManager();
+  await promiseShutdownManager();
   let extension = gProfD.clone();
   extension.append("extensions");
   extension.append("addon1@tests.mozilla.org.xpi");
   setExtensionModifiedTime(extension, Date.now() - MAKE_FILE_OLD_DIFFERENCE);
-  startupManager();
+  await promiseStartupManager();
 }
 
 function run_test() {
   do_test_pending();
 
   run_test_1();
 }
 
 // Tests that on the first startup the add-on gets installed, with now as the
 // profile modifiedTime.
 async function run_test_1() {
-  let extension = writeInstallRDFForExtension(addon1_1, distroDir);
+  let extension = await promiseWriteInstallRDFForExtension(addon1_1, distroDir);
   setExtensionModifiedTime(extension, Date.now() - MAKE_FILE_OLD_DIFFERENCE);
 
-  startupManager();
+  await promiseStartupManager();
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "1.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
   Assert.ok(!a1.foreignInstall);
 
@@ -103,134 +103,134 @@ async function run_test_1() {
   Assert.ok(Math.abs(difference) < MAX_TIME_DIFFERENCE);
 
   executeSoon(run_test_2);
 }
 
 // Tests that starting with a newer version in the distribution dir doesn't
 // install it yet
 async function run_test_2() {
-  setOldModificationTime();
+  await setOldModificationTime();
 
-  writeInstallRDFForExtension(addon1_2, distroDir);
+  await promiseWriteInstallRDFForExtension(addon1_2, distroDir);
 
-  restartManager();
+  await promiseRestartManager();
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "1.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
 
   executeSoon(run_test_3);
 }
 
 // Test that an app upgrade installs the newer version
 async function run_test_3() {
-  restartManager("2");
+  await promiseRestartManager("2");
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "2.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
   Assert.ok(!a1.foreignInstall);
 
   executeSoon(run_test_4);
 }
 
 // Test that an app upgrade doesn't downgrade the extension
 async function run_test_4() {
-  setOldModificationTime();
+  await setOldModificationTime();
 
-  writeInstallRDFForExtension(addon1_1, distroDir);
+  await promiseWriteInstallRDFForExtension(addon1_1, distroDir);
 
-  restartManager("3");
+  await promiseRestartManager("3");
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "2.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
 
   executeSoon(run_test_5);
 }
 
 // Tests that after uninstalling a restart doesn't re-install the extension
 async function run_test_5() {
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   a1.uninstall();
 
-  restartManager();
+  await promiseRestartManager();
 
   let a1_2 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.equal(a1_2, null);
 
   executeSoon(run_test_6);
 }
 
 // Tests that upgrading the application still doesn't re-install the uninstalled
 // extension
 async function run_test_6() {
-  restartManager("4");
+  await promiseRestartManager("4");
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.equal(a1, null);
 
   executeSoon(run_test_7);
 }
 
 // Tests that a pending install of a newer version of a distributed add-on
 // at app change still gets applied
 async function run_test_7() {
   Services.prefs.clearUserPref("extensions.installedDistroAddon.addon1@tests.mozilla.org");
 
   await promiseInstallAllFiles([do_get_addon("test_distribution1_2")]);
-  restartManager(2);
+  await promiseRestartManager(2);
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "2.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
 
   a1.uninstall();
   executeSoon(run_test_8);
 }
 
 // Tests that a pending install of a older version of a distributed add-on
 // at app change gets replaced by the distributed version
 async function run_test_8() {
-  restartManager();
+  await promiseRestartManager();
 
-  writeInstallRDFForExtension(addon1_3, distroDir);
+  await promiseWriteInstallRDFForExtension(addon1_3, distroDir);
 
   await promiseInstallAllFiles([do_get_addon("test_distribution1_2")]);
-  restartManager(3);
+  await promiseRestartManager(3);
 
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
   Assert.equal(a1.version, "3.0");
   Assert.ok(a1.isActive);
   Assert.equal(a1.scope, AddonManager.SCOPE_PROFILE);
 
   a1.uninstall();
   executeSoon(run_test_9);
 }
 
 // Tests that bootstrapped add-ons distributed start up correctly, also that
 // add-ons with multiple directories get copied fully
 async function run_test_9() {
-  restartManager();
+  await promiseRestartManager();
 
   // Copy the test add-on to the distro dir
   let addon = do_get_file("data/test_distribution2_2");
   addon.copyTo(distroDir, "addon2@tests.mozilla.org");
 
-  restartManager("5");
+  await promiseRestartManager("5");
 
   let a2 = await AddonManager.getAddonByID("addon2@tests.mozilla.org");
   Assert.notEqual(a2, null);
   Assert.ok(a2.isActive);
 
   Assert.equal(getInstalledVersion(), 2);
   Assert.equal(getActiveVersion(), 2);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_duplicateplugins.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_duplicateplugins.js
@@ -64,22 +64,22 @@ var PLUGINS = [{
   enabledState: Ci.nsIPluginTag.STATE_ENABLED,
   filename: "/home/mozilla/.plugins/dupplugin5.so"
 }].map(opts => new MockPlugin(opts));
 
 mockPluginHost(PLUGINS);
 
 var gPluginIDs = [null, null, null, null, null];
 
-function run_test() {
+async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
   Services.prefs.setBoolPref("media.gmp-provider.enabled", false);
 
-  startupManager();
+  await promiseStartupManager();
 
   run_test_1();
 }
 
 function found_plugin(aNum, aId) {
   if (gPluginIDs[aNum])
     do_throw("Found duplicate of plugin " + aNum);
   gPluginIDs[aNum] = aId;
@@ -122,26 +122,26 @@ async function run_test_2() {
   Assert.ok(PLUGINS[0].disabled);
   Assert.ok(PLUGINS[1].disabled);
 
   executeSoon(run_test_3);
 }
 
 // Test that IDs persist across restart
 async function run_test_3() {
-  restartManager();
+  await promiseRestartManager();
 
   let p = await AddonManager.getAddonByID(gPluginIDs[0]);
   Assert.notEqual(p, null);
   Assert.equal(p.name, "Duplicate Plugin 1");
   Assert.equal(p.description, "A duplicate plugin");
 
   // Reorder the plugins and restart again
   [PLUGINS[0], PLUGINS[1]] = [PLUGINS[1], PLUGINS[0]];
-  restartManager();
+  await promiseRestartManager();
 
   let p_2 = await AddonManager.getAddonByID(gPluginIDs[0]);
   Assert.notEqual(p_2, null);
   Assert.equal(p_2.name, "Duplicate Plugin 1");
   Assert.equal(p_2.description, "A duplicate plugin");
 
   executeSoon(do_test_finished);
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_error.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_error.js
@@ -4,22 +4,22 @@
 
 // Tests that various error conditions are handled correctly
 
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
-function run_test() {
+async function run_test() {
+  do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
-  startupManager();
+  await promiseStartupManager();
 
-  do_test_pending();
   run_test_1();
 }
 
 // Checks that a local file validates ok
 async function run_test_1() {
   let install = await AddonManager.getInstallForFile(do_get_file("data/unsigned.xpi"));
   Assert.notEqual(install, null);
   Assert.equal(install.state, AddonManager.STATE_DOWNLOADED);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_ext_management.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_ext_management.js
@@ -1,13 +1,13 @@
 "use strict";
 
 add_task(async function setup() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "48", "48");
-  startupManager();
+  await promiseStartupManager();
 });
 
 /* eslint-disable no-undef */
 // Shared background function for getSelf tests
 function backgroundGetSelf() {
   browser.management.getSelf().then(extInfo => {
     let url = browser.extension.getURL("*");
     extInfo.hostPermissions = extInfo.hostPermissions.filter(i => i != url);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_filepointer.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_filepointer.js
@@ -204,27 +204,27 @@ add_task(async function test_bad_pointer
 
   let pointer = profileDir.clone();
   pointer.append("addon2@tests.mozilla.org");
   ok(!pointer.exists());
 });
 
 // Tests that changing the ID of an existing add-on doesn't clobber the sources
 add_task(async function test_bad_pointer_id() {
-  var dest = writeInstallRDFForExtension(addon1, sourceDir);
+  var dest = await promiseWriteInstallRDFForExtension(addon1, sourceDir);
   // Make sure the modification time changes enough to be detected.
   setExtensionModifiedTime(dest, dest.lastModifiedTime - 5000);
   await promiseWritePointer(addon1.id);
   await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID(addon1.id);
   notEqual(addon, null);
   equal(addon.version, "1.0");
 
-  writeInstallRDFForExtension(addon2, sourceDir, addon1.id);
+  await promiseWriteInstallRDFForExtension(addon2, sourceDir, addon1.id);
 
   await promiseRestartManager();
 
   let [a1, a2] = await AddonManager.getAddonsByIDs(
     ["addon1@tests.mozilla.org", "addon2@tests.mozilla.org"]);
 
   equal(a1, null);
   equal(a2, null);
@@ -235,17 +235,17 @@ add_task(async function test_bad_pointer
 
   let pointer = profileDir.clone();
   pointer.append(addon1.id);
   ok(!pointer.exists());
 });
 
 // Removing the pointer file should uninstall the add-on
 add_task(async function test_remove_pointer() {
-  var dest = writeInstallRDFForExtension(addon1, sourceDir);
+  var dest = await promiseWriteInstallRDFForExtension(addon1, sourceDir);
   // Make sure the modification time changes enough to be detected in run_test_8.
   setExtensionModifiedTime(dest, dest.lastModifiedTime - 5000);
   await promiseWritePointer(addon1.id);
 
   await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID(addon1.id);
   notEqual(addon, null);
@@ -269,17 +269,17 @@ add_task(async function test_replace_poi
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   notEqual(addon, null);
   equal(addon.version, "1.0");
 
   let pointer = profileDir.clone();
   pointer.append(addon1.id);
   pointer.remove(false);
 
-  writeInstallRDFForExtension(addon1_2, profileDir);
+  await promiseWriteInstallRDFForExtension(addon1_2, profileDir);
 
   await promiseRestartManager();
 
   addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   notEqual(addon, null);
   equal(addon.version, "2.0");
 
   addon.uninstall();
@@ -290,31 +290,31 @@ add_task(async function test_change_poin
   await promiseRestartManager();
   await promiseWritePointer(addon1.id);
   await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   notEqual(addon, null);
   equal(addon.version, "1.0");
 
-  writeInstallRDFForExtension(addon1_2, sourceDir);
+  await promiseWriteInstallRDFForExtension(addon1_2, sourceDir);
 
   await promiseRestartManager();
 
   addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   notEqual(addon, null);
   equal(addon.version, "2.0");
 
   addon.uninstall();
 });
 
 // Removing the add-on the pointer file points at should uninstall the add-on
 add_task(async function test_remove_pointer_target() {
   await promiseRestartManager();
-  var dest = writeInstallRDFForExtension(addon1, sourceDir);
+  var dest = await promiseWriteInstallRDFForExtension(addon1, sourceDir);
   await promiseWritePointer(addon1.id);
   await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID(addon1.id);
   notEqual(addon, null);
   equal(addon.version, "1.0");
 
   dest.remove(true);
@@ -326,17 +326,17 @@ add_task(async function test_remove_poin
 
   let pointer = profileDir.clone();
   pointer.append(addon1.id);
   ok(!pointer.exists());
 });
 
 // Tests that installing a new add-on by pointer with a relative path works
 add_task(async function test_new_relative_pointer() {
-  writeInstallRDFForExtension(addon1, sourceDir);
+  await promiseWriteInstallRDFForExtension(addon1, sourceDir);
   await promiseWriteRelativePointer(addon1.id);
   await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID(addon1.id);
   equal(addon.version, "1.0");
 
   let file = addon.getResourceURI().QueryInterface(Ci.nsIFileURL).file;
   equal(file.parent.path, sourceDir.path);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_general.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_general.js
@@ -8,45 +8,45 @@
 // We have to look up how many add-ons are present since there will be plugins
 // etc. detected
 var gCount;
 
 async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
-  startupManager();
+  await promiseStartupManager();
   let list = await AddonManager.getAddonsByTypes(null);
   gCount = list.length;
 
   executeSoon(run_test_1);
 }
 
 async function run_test_1() {
-  restartManager();
+  await promiseRestartManager();
 
   let addons = await AddonManager.getAddonsByTypes(null);
   Assert.equal(gCount, addons.length);
 
   let pendingAddons = await AddonManager.getAddonsWithOperationsByTypes(null);
   Assert.equal(0, pendingAddons.length);
 
   executeSoon(run_test_2);
 }
 
 async function run_test_2() {
-  shutdownManager();
+  await promiseShutdownManager();
 
-  startupManager();
+  await promiseStartupManager();
 
   let addons = await AddonManager.getAddonsByTypes(null);
   Assert.equal(gCount, addons.length);
 
   executeSoon(run_test_3);
 }
 
 async function run_test_3() {
-  restartManager();
+  await promiseRestartManager();
 
   let addons = await AddonManager.getAddonsByTypes(null);
   Assert.equal(gCount, addons.length);
   do_test_finished();
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_getresource.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_getresource.js
@@ -8,17 +8,17 @@ const ADDON_SIZE = 672 + 15 + 26;
 // This verifies the functionality of getResourceURI
 // There are two cases - with a filename it returns an nsIFileURL to the filename
 // and with no parameters, it returns an nsIFileURL to the root of the addon
 
 async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1");
 
-  startupManager();
+  await promiseStartupManager();
 
   let aInstall = await AddonManager.getInstallForFile(do_get_addon("test_getresource"));
   Assert.ok(aInstall.addon.hasResource("install.rdf"));
   Assert.equal(aInstall.addon.getResourceURI().spec, aInstall.sourceURI.spec);
 
   Assert.ok(aInstall.addon.hasResource("icon.png"));
   Assert.equal(aInstall.addon.getResourceURI("icon.png").spec,
                "jar:" + aInstall.sourceURI.spec + "!/icon.png");
@@ -29,17 +29,17 @@ async function run_test() {
   Assert.equal(aInstall.addon.getResourceURI("subdir/subfile.txt").spec,
                "jar:" + aInstall.sourceURI.spec + "!/subdir/subfile.txt");
 
   Assert.ok(!aInstall.addon.hasResource("subdir/missing.txt"));
 
   Assert.equal(aInstall.addon.size, ADDON_SIZE);
 
   await promiseCompleteAllInstalls([aInstall]);
-  restartManager();
+  await promiseRestartManager();
   let a1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(a1, null);
 
   let addonDir = gProfD.clone();
   addonDir.append("extensions");
   let rootUri = do_get_addon_root_uri(addonDir, "addon1@tests.mozilla.org");
 
   let uri = a1.getResourceURI("/");
@@ -74,15 +74,15 @@ async function run_test() {
   } catch (e) {
     Assert.ok(false);
   }
 
   let aInstall_2 = await AddonManager.getInstallForFile(do_get_addon("test_getresource"));
   Assert.ok(!a1.hasResource("icon.png"));
   Assert.ok(aInstall_2.addon.hasResource("icon.png"));
 
-  restartManager();
+  await promiseRestartManager();
 
   let newa1 = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.equal(newa1, null);
 
   executeSoon(do_test_finished);
 }

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Device.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Device.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       gfxInfo.spoofVendorID("abcd");
       gfxInfo.spoofDeviceID("aabb");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_DriverNew.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_DriverNew.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("abcd");
       gfxInfo.spoofDeviceID("wxyz");
       gfxInfo.spoofDriverVersion("6");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_DriverNew.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_DriverNew.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("dcdc");
       gfxInfo.spoofDeviceID("uiop");
       gfxInfo.spoofDriverVersion("6");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "15.0", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_DriverOld.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_DriverOld.js
@@ -16,17 +16,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("dcdc");
       gfxInfo.spoofDeviceID("uiop");
       gfxInfo.spoofDriverVersion("4");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_OK.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Equal_OK.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("dcdc");
       gfxInfo.spoofDeviceID("uiop");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_GTE_DriverOld.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_GTE_DriverOld.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("abab");
       gfxInfo.spoofDeviceID("ghjk");
       gfxInfo.spoofDriverVersion("6");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_GTE_OK.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_GTE_OK.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       return;
     case "Android":
       gfxInfo.spoofVendorID("abab");
       gfxInfo.spoofDeviceID("ghjk");
       gfxInfo.spoofDriverVersion("7");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_No_Comparison.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_No_Comparison.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -44,20 +44,20 @@ function run_test() {
       break;
     case "Darwin":
       gfxInfo.spoofOSVersion(0x1090);
       break;
     case "Android":
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var driverVersion = gfxInfo.adapterDriverVersion;
     if (driverVersion) {
       var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DEVICE);
 
       // Make sure unrelated features aren't affected

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OK.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OK.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       gfxInfo.spoofVendorID("abcd");
       gfxInfo.spoofDeviceID("asdf");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);
 
     // Make sure unrelated features aren't affected
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OS.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OS.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       // On Android, the driver version is used as the OS version (because
       // there's so many of them).
       do_test_finished();
       return;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_match.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_match.js
@@ -14,17 +14,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       // On Android, the driver version is used as the OS version (because
       // there's so many of them).
       do_test_finished();
       return;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     if (Services.appinfo.OS == "WINNT") {
       var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);
     } else if (Services.appinfo.OS == "Darwin") {
       status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_OPENGL_LAYERS);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_mismatch_DriverVersion.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_mismatch_DriverVersion.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       // On Android, the driver version is used as the OS version (because
       // there's so many of them).
       do_test_finished();
       return;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     if (Services.appinfo.OS == "WINNT") {
       var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
     } else if (Services.appinfo.OS == "Darwin") {
       status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_OPENGL_LAYERS);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_mismatch_OSVersion.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_OSVersion_mismatch_OSVersion.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -52,20 +52,20 @@ function run_test() {
       break;
     case "Android":
       // On Android, the driver version is used as the OS version (because
       // there's so many of them).
       do_test_finished();
       return;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     if (Services.appinfo.OS == "WINNT") {
       var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
     } else if (Services.appinfo.OS == "Darwin") {
       status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_OPENGL_LAYERS);
       Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Vendor.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Vendor.js
@@ -15,17 +15,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -51,20 +51,20 @@ function run_test() {
       break;
     case "Android":
       gfxInfo.spoofVendorID("dcba");
       gfxInfo.spoofDeviceID("asdf");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT3D_9_LAYERS);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_STATUS_OK);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Version.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_Version.js
@@ -14,17 +14,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
 
   // We can't do anything if we can't spoof the stuff we need.
   if (!(gfxInfo instanceof Ci.nsIGfxInfoDebug)) {
     do_test_finished();
     return;
   }
 
@@ -50,20 +50,20 @@ function run_test() {
       break;
     case "Android":
       gfxInfo.spoofVendorID("abcd");
       gfxInfo.spoofDeviceID("asdf");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "15.0", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function checkBlacklist() {
     var failureId = {};
     var status;
 
     status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D, failureId);
     Assert.equal(status, Ci.nsIGfxInfo.FEATURE_BLOCKED_DRIVER_VERSION);
     Assert.equal(failureId.value, "FEATURE_FAILURE_DL_BLACKLIST_g1");

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_prefs.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_prefs.js
@@ -14,17 +14,17 @@ function load_blocklist(file) {
   Services.prefs.setCharPref("extensions.blocklist.url", "http://localhost:" +
                              gPort + "/data/" + file);
   var blocklist = Cc["@mozilla.org/extensions/blocklist;1"].
                   getService(Ci.nsITimerCallback);
   blocklist.notify(null);
 }
 
 // Performs the initial setup
-function run_test() {
+async function run_test() {
   try {
     var gfxInfo = Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo);
   } catch (e) {
     do_test_finished();
     return;
   }
 
   // We can't do anything if we can't spoof the stuff we need.
@@ -55,20 +55,20 @@ function run_test() {
       break;
     case "Android":
       gfxInfo.spoofVendorID("abcd");
       gfxInfo.spoofDeviceID("asdf");
       gfxInfo.spoofDriverVersion("5");
       break;
   }
 
+  do_test_pending();
+
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "3", "8");
-  startupManager();
-
-  do_test_pending();
+  await promiseStartupManager();
 
   function blacklistAdded(aSubject, aTopic, aData) {
     // If we wait until after we go through the event loop, gfxInfo is sure to
     // have processed the gfxItems event.
     executeSoon(ensureBlacklistSet);
   }
   function ensureBlacklistSet() {
     var status = gfxInfo.getFeatureStatus(Ci.nsIGfxInfo.FEATURE_DIRECT2D);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gmpProvider.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gmpProvider.js
@@ -48,32 +48,30 @@ MockGMPInstallManager.prototype = {
 
   installAddon: addon => {
     gInstalledAddonId = addon.id;
     return Promise.resolve();
   },
 };
 
 
-function run_test() {
+add_task(async function setup() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
-  startupManager();
+  await promiseStartupManager();
 
   gPrefs.setBoolPref(GMPScope.GMPPrefs.KEY_LOGGING_DUMP, true);
   gPrefs.setIntPref(GMPScope.GMPPrefs.KEY_LOGGING_LEVEL, 0);
   gPrefs.setBoolPref(GMPScope.GMPPrefs.KEY_EME_ENABLED, true);
   for (let addon of gMockAddons.values()) {
     gPrefs.setBoolPref(gGetKey(GMPScope.GMPPrefs.KEY_PLUGIN_VISIBLE, addon.id),
                        true);
     gPrefs.setBoolPref(gGetKey(GMPScope.GMPPrefs.KEY_PLUGIN_FORCE_SUPPORTED, addon.id),
                        true);
   }
-
-  run_next_test();
-}
+});
 
 add_task(async function init() {
   await GMPScope.GMPProvider.shutdown();
   GMPScope.GMPProvider.startup();
 });
 
 add_task(async function test_notInstalled() {
   for (let addon of gMockAddons.values()) {

--- a/toolkit/mozapps/extensions/test/xpcshell/test_install_icons.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_install_icons.js
@@ -7,20 +7,20 @@ ChromeUtils.import("resource://testing-c
 var gServer = new HttpServer();
 gServer.start(-1);
 gPort = gServer.identity.primaryPort;
 
 var addon_url = "http://localhost:" + gPort + "/test.xpi";
 var icon32_url = "http://localhost:" + gPort + "/icon.png";
 var icon64_url = "http://localhost:" + gPort + "/icon64.png";
 
-function run_test() {
+async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
-  startupManager();
+  await promiseStartupManager();
 
   test_1();
 }
 
 async function test_1() {
   let aInstall = await AddonManager.getInstallForURL(addon_url, "application/x-xpinstall", null, null, null, null, null);
   Assert.equal(aInstall.iconURL, null);
   Assert.notEqual(aInstall.icons, null);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_isReady.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_isReady.js
@@ -11,17 +11,17 @@ add_task(async function() {
     },
     onShutdown() {
       gotShutdownEvent = true;
     },
   };
   AddonManager.addManagerListener(listener);
 
   info("Starting manager...");
-  startupManager();
+  await promiseStartupManager();
   equal(AddonManager.isReady, true, "isReady should be true after startup");
   equal(gotStartupEvent, true, "Should have seen onStartup event after startup");
   equal(gotShutdownEvent, false, "Should not have seen onShutdown event before shutdown");
 
   gotStartupEvent = false;
   gotShutdownEvent = false;
 
   info("Shutting down manager...");
@@ -33,13 +33,13 @@ add_task(async function() {
   equal(gotStartupEvent, false, "Should not have seen onStartup event after shutdown");
   equal(gotShutdownEvent, true, "Should have seen onShutdown event after shutdown");
 
   AddonManager.addManagerListener(listener);
   gotStartupEvent = false;
   gotShutdownEvent = false;
 
   info("Starting manager again...");
-  startupManager();
+  await promiseStartupManager();
   equal(AddonManager.isReady, true, "isReady should be true after repeat startup");
   equal(gotStartupEvent, true, "Should have seen onStartup event after repeat startup");
   equal(gotShutdownEvent, false, "Should not have seen onShutdown event before shutdown, following repeat startup");
 });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_json_updatecheck.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_json_updatecheck.js
@@ -70,17 +70,17 @@ function checkUpdates(aData) {
     });
   });
 }
 
 
 add_task(async function test_default_values() {
   // Checks that the appropriate defaults are used for omitted values.
 
-  startupManager();
+  await promiseStartupManager();
 
   let updates = await checkUpdates({
     id: "updatecheck-defaults@tests.mozilla.org",
     version: "0.1",
     updates: [{
       version: "0.2"
     }]
   });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_locale.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_locale.js
@@ -1,20 +1,20 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
-function run_test() {
+async function run_test() {
   do_test_pending();
 
   // Setup for test
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
   Services.locale.setRequestedLocales(["fr-FR"]);
 
-  startupManager();
+  await promiseStartupManager();
 
   run_test_1();
 }
 
 // Tests that the localized properties are visible before installation
 async function run_test_1() {
   let install = await AddonManager.getInstallForFile(do_get_addon("test_locale"));
   Assert.equal(install.addon.name, "fr-FR Name");
@@ -29,103 +29,103 @@ async function run_test_1() {
     "onInstallStarted",
     "onInstallEnded",
   ], callback_soon(run_test_2));
   install.install();
 }
 
 // Tests that the localized properties are visible after installation
 async function run_test_2() {
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
 
   Assert.equal(addon.name, "fr-FR Name");
   Assert.equal(addon.description, "fr-FR Description");
 
   addon.userDisabled = true;
   executeSoon(run_test_3);
 }
 
 // Test that the localized properties are still there when disabled.
 async function run_test_3() {
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
   Assert.equal(addon.name, "fr-FR Name");
 
   executeSoon(run_test_4);
 }
 
 // Localised preference values should be ignored when the add-on is disabled
 async function run_test_4() {
   Services.prefs.setCharPref("extensions.addon1@tests.mozilla.org.name", "Name from prefs");
   Services.prefs.setCharPref("extensions.addon1@tests.mozilla.org.contributor.1", "Contributor 1");
   Services.prefs.setCharPref("extensions.addon1@tests.mozilla.org.contributor.2", "Contributor 2");
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
   Assert.equal(addon.name, "fr-FR Name");
   let contributors = addon.contributors;
   Assert.equal(contributors.length, 3);
   Assert.equal(contributors[0], "Fr Contributor 1");
   Assert.equal(contributors[1], "Fr Contributor 2");
   Assert.equal(contributors[2], "Fr Contributor 3");
 
   executeSoon(run_test_5);
 }
 
 // Test that changing locale works
 async function run_test_5() {
   Services.locale.setRequestedLocales(["de-DE"]);
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
 
   Assert.equal(addon.name, "de-DE Name");
   Assert.equal(addon.description, null);
 
   executeSoon(run_test_6);
 }
 
 // Test that missing locales use the fallbacks
 async function run_test_6() {
   Services.locale.setRequestedLocales(["nl-NL"]);
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
 
   Assert.equal(addon.name, "Fallback Name");
   Assert.equal(addon.description, "Fallback Description");
 
   addon.userDisabled = false;
   executeSoon(run_test_7);
 }
 
 // Test that the prefs will override the fallbacks
 async function run_test_7() {
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
 
   Assert.equal(addon.name, "Name from prefs");
 
   executeSoon(run_test_8);
 }
 
 // Test that the prefs will override localized values from the manifest
 async function run_test_8() {
   Services.locale.setRequestedLocales(["fr-FR"]);
-  restartManager();
+  await promiseRestartManager();
 
   let addon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(addon, null);
 
   Assert.equal(addon.name, "Name from prefs");
   let contributors = addon.contributors;
   Assert.equal(contributors.length, 2);
   Assert.equal(contributors[0], "Contributor 1");

--- a/toolkit/mozapps/extensions/test/xpcshell/test_manifest_locales.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_manifest_locales.js
@@ -76,17 +76,17 @@ add_task(async function setup() {
 add_task(async function test_1() {
   let addon = await AddonManager.getAddonByID(ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.name, "fr Name");
   Assert.equal(addon.description, "fr Description");
 
   // Disable item
   addon.userDisabled = true;
-  restartManager();
+  await promiseRestartManager();
 
   let newAddon = await AddonManager.getAddonByID(ID);
   Assert.notEqual(newAddon, null);
   Assert.equal(newAddon.name, "fr Name");
 });
 
 add_task(async function test_2() {
   // Change locale. The more specific de-DE is the best match

--- a/toolkit/mozapps/extensions/test/xpcshell/test_moved_extension_metadata.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_moved_extension_metadata.js
@@ -72,20 +72,20 @@ const ADDONS = [
     `
   },
 ];
 
 const XPIS = ADDONS.map(addon => AddonTestUtils.createTempXPIFile(addon));
 
 add_task(async function test_1() {
   var time = Date.now();
-  var dir = writeInstallRDFForExtension(addon1, userDir);
+  var dir = await promiseWriteInstallRDFForExtension(addon1, userDir);
   setExtensionModifiedTime(dir, time);
 
-  manuallyInstall(XPIS[0], userDir, "addon2@tests.mozilla.org");
+  await manuallyInstall(XPIS[0], userDir, "addon2@tests.mozilla.org");
 
   await promiseStartupManager();
 
   let [a1, a2] = await AddonManager.getAddonsByIDs(["addon1@tests.mozilla.org",
                                                     "addon2@tests.mozilla.org"]);
   Assert.notEqual(a1, null);
   Assert.ok(a1.appDisabled);
   Assert.ok(!a1.isActive);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_no_addons.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_no_addons.js
@@ -30,17 +30,17 @@ function check_empty_state() {
 // After first run with no add-ons, we expect:
 // no extensions.json is created
 // no extensions.ini
 // database schema version preference is set
 // bootstrap add-ons preference is not found
 // add-on directory state preference is an empty array
 // no pending operations
 add_task(async function first_run() {
-  startupManager();
+  await promiseStartupManager();
   check_empty_state();
   await true;
 });
 
 // Now do something that causes a DB load, and re-check
 async function trigger_db_load() {
   let addonList = await AddonManager.getAddonsByTypes(["extension"]);
 
@@ -48,26 +48,26 @@ async function trigger_db_load() {
   check_empty_state();
 
   await true;
 }
 add_task(trigger_db_load);
 
 // Now restart the manager and check again
 add_task(async function restart_and_recheck() {
-  restartManager();
+  await promiseRestartManager();
   check_empty_state();
   await true;
 });
 
 // and reload the DB again
 add_task(trigger_db_load);
 
 // When we start up with no DB and an old database schema, we should update the
 // schema number but not create a database
-add_task(function upgrade_schema_version() {
-  shutdownManager();
+add_task(async function upgrade_schema_version() {
+  await promiseShutdownManager();
   Services.prefs.setIntPref("extensions.databaseSchema", 1);
 
-  startupManager();
+  await promiseStartupManager();
   Assert.equal(Services.prefs.getIntPref("extensions.databaseSchema"), DB_SCHEMA);
   check_empty_state();
 });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_nodisable_hidden.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_nodisable_hidden.js
@@ -13,29 +13,29 @@ registerDirectory("XREAppFeat", distroDi
 const NORMAL_ID = "normal@tests.mozilla.org";
 const SYSTEM_ID = "system@tests.mozilla.org";
 
 createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "42");
 
 // normal add-ons can be user disabled.
 add_task(async function() {
 
-  writeInstallRDFToXPI({
+  await promiseWriteInstallRDFToXPI({
     id: NORMAL_ID,
     version: "1.0",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "1"
     }],
     name: "Test disabling hidden add-ons, non-hidden add-on case.",
   }, profileDir, NORMAL_ID);
 
-  startupManager();
+  await promiseStartupManager();
 
   let addon = await promiseAddonByID(NORMAL_ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test disabling hidden add-ons, non-hidden add-on case.");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(!addon.userDisabled);
@@ -51,37 +51,37 @@ add_task(async function() {
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(addon.userDisabled);
   Assert.ok(!addon.isActive);
   Assert.equal(addon.type, "extension");
 
   addon.uninstall();
 
-  shutdownManager();
+  await promiseShutdownManager();
 });
 
 // system add-ons can never be user disabled.
 add_task(async function() {
 
-  writeInstallRDFToXPI({
+  await promiseWriteInstallRDFToXPI({
     id: SYSTEM_ID,
     version: "1.0",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "1",
       maxVersion: "1"
     }],
     name: "Test disabling hidden add-ons, hidden system add-on case.",
   }, distroDir, SYSTEM_ID);
 
   await overrideBuiltIns({ "system": [SYSTEM_ID] });
 
-  startupManager();
+  await promiseStartupManager();
 
   let addon = await promiseAddonByID(SYSTEM_ID);
   Assert.notEqual(addon, null);
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test disabling hidden add-ons, hidden system add-on case.");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(!addon.userDisabled);
@@ -100,10 +100,10 @@ add_task(async function() {
   Assert.equal(addon.version, "1.0");
   Assert.equal(addon.name, "Test disabling hidden add-ons, hidden system add-on case.");
   Assert.ok(addon.isCompatible);
   Assert.ok(!addon.appDisabled);
   Assert.ok(!addon.userDisabled);
   Assert.ok(addon.isActive);
   Assert.equal(addon.type, "extension");
 
-  shutdownManager();
+  await promiseShutdownManager();
 });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_onPropertyChanged_appDisabled.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_onPropertyChanged_appDisabled.js
@@ -3,40 +3,40 @@
 
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 
 async function run_test() {
   do_test_pending();
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
 
-  writeInstallRDFForExtension({
+  await promiseWriteInstallRDFForExtension({
     id: "addon1@tests.mozilla.org",
     version: "1.0",
     name: "Test 1",
     bootstrap: true,
     targetApplications: [{
       id: "xpcshell@tests.mozilla.org",
       minVersion: "0.1",
       maxVersion: "0.2"
     }]
   }, profileDir);
 
-  startupManager();
+  await promiseStartupManager();
 
   AddonManager.strictCompatibility = false;
 
   let aAddon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(aAddon, null);
   aAddon.userDisabled = true;
   executeSoon(run_test_1);
 }
 
 async function run_test_1() {
-  restartManager();
+  await promiseRestartManager();
   let aAddon = await AddonManager.getAddonByID("addon1@tests.mozilla.org");
   Assert.notEqual(aAddon, null);
   Assert.ok(aAddon.userDisabled);
   Assert.ok(!aAddon.isActive);
   Assert.ok(!aAddon.appDisabled);
 
   prepare_test({
     "addon1@tests.mozilla.org": [

--- a/toolkit/mozapps/extensions/test/xpcshell/test_overrideblocklist.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_overrideblocklist.js
@@ -90,109 +90,109 @@ async function isBlocklisted(addon, appV
 }
 
 // On first run whataver is in the app dir should get copied to the profile
 add_test(async function test_copy() {
   clearBlocklists();
   copyToApp(OLD);
 
   incrementAppVersion();
-  startupManager();
+  await promiseStartupManager();
 
   reloadBlocklist();
   Assert.ok(!(await isBlocklisted(invalidAddon)));
   Assert.ok(!(await isBlocklisted(ancientAddon)));
   Assert.ok(await isBlocklisted(oldAddon));
   Assert.ok(!(await isBlocklisted(newAddon)));
 
-  shutdownManager();
+  await promiseShutdownManager();
 
   run_next_test();
 });
 
 // An ancient blocklist should be ignored
 add_test(async function test_ancient() {
   clearBlocklists();
   copyToApp(ANCIENT);
   copyToProfile(OLD, OLD_TSTAMP);
 
   incrementAppVersion();
-  startupManager();
+  await promiseStartupManager();
 
   reloadBlocklist();
 
   Assert.ok(!(await isBlocklisted(invalidAddon)));
   Assert.ok(!(await isBlocklisted(ancientAddon)));
   Assert.ok(await isBlocklisted(oldAddon));
   Assert.ok(!(await isBlocklisted(newAddon)));
 
-  shutdownManager();
+  await promiseShutdownManager();
 
   run_next_test();
 });
 
 // A new blocklist should override an old blocklist
 add_test(async function test_override() {
   clearBlocklists();
   copyToApp(NEW);
   copyToProfile(OLD, OLD_TSTAMP);
 
   incrementAppVersion();
-  startupManager();
+  await promiseStartupManager();
 
   reloadBlocklist();
 
   Assert.ok(!(await isBlocklisted(invalidAddon)));
   Assert.ok(!(await isBlocklisted(ancientAddon)));
   Assert.ok(!(await isBlocklisted(oldAddon)));
   Assert.ok(await isBlocklisted(newAddon));
 
-  shutdownManager();
+  await promiseShutdownManager();
 
   run_next_test();
 });
 
 // An old blocklist shouldn't override a new blocklist
 add_test(async function test_retain() {
   clearBlocklists();
   copyToApp(OLD);
   copyToProfile(NEW, NEW_TSTAMP);
 
   incrementAppVersion();
-  startupManager();
+  await promiseStartupManager();
 
   reloadBlocklist();
 
   Assert.ok(!(await isBlocklisted(invalidAddon)));
   Assert.ok(!(await isBlocklisted(ancientAddon)));
   Assert.ok(!(await isBlocklisted(oldAddon)));
   Assert.ok(await isBlocklisted(newAddon));
 
-  shutdownManager();
+  await promiseShutdownManager();
 
   run_next_test();
 });
 
 // A missing blocklist in the profile should still load an app-shipped blocklist
 add_test(async function test_missing() {
   clearBlocklists();
   copyToApp(OLD);
   copyToProfile(NEW, NEW_TSTAMP);
 
   incrementAppVersion();
-  startupManager();
-  shutdownManager();
+  await promiseStartupManager();
+  await promiseShutdownManager();
 
   let blocklist = FileUtils.getFile(KEY_PROFILEDIR, [FILE_BLOCKLIST]);
   blocklist.remove(true);
-  startupManager();
+  await promiseStartupManager();
 
   reloadBlocklist();
 
   Assert.ok(!(await isBlocklisted(invalidAddon)));
   Assert.ok(!(await isBlocklisted(ancientAddon)));
   Assert.ok(await isBlocklisted(oldAddon));
   Assert.ok(!(await isBlocklisted(newAddon)));
 
-  shutdownManager();
+  await promiseShutdownManager();
 
   run_next_test();
 });