Bug 887889 - Asyncify cps2 tests r=mak
authorDoug Thayer <dothayer@mozilla.com>
Mon, 12 Mar 2018 14:46:24 -0700
changeset 415935 744a7b9fe0abd1095d0f5ba464161d51a97a33b7
parent 415934 29598c587f7fb07c434df30534bdf489f987562d
child 415936 e7f2bc2cb13cbf63ef78ce215d0c393f2bd3ef87
push id33911
push usercsabou@mozilla.com
push dateFri, 27 Apr 2018 10:01:39 +0000
treeherdermozilla-central@822936017145 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmak
bugs887889
milestone61.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 887889 - Asyncify cps2 tests r=mak I converted the cps2 tests to use async/await, since it was easier for me to debug the breakages introduced by my changes that way. There are a few differences hidden in there, though - most notable is that I also modified the direct db access in the tests to use the Sqlite.jsm wrapper. This was to avoid reaching into the connections internals in order to get the underlying connection. MozReview-Commit-ID: DwJ5hfyvAOf
toolkit/components/contentprefs/tests/unit_cps2/head.js
toolkit/components/contentprefs/tests/unit_cps2/test_getCached.js
toolkit/components/contentprefs/tests/unit_cps2/test_getCachedSubdomains.js
toolkit/components/contentprefs/tests/unit_cps2/test_getSubdomains.js
toolkit/components/contentprefs/tests/unit_cps2/test_migrationToSchema4.js
toolkit/components/contentprefs/tests/unit_cps2/test_observers.js
toolkit/components/contentprefs/tests/unit_cps2/test_remove.js
toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomains.js
toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomainsSince.js
toolkit/components/contentprefs/tests/unit_cps2/test_removeByDomain.js
toolkit/components/contentprefs/tests/unit_cps2/test_removeByName.js
toolkit/components/contentprefs/tests/unit_cps2/test_setGet.js
--- a/toolkit/components/contentprefs/tests/unit_cps2/head.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/head.js
@@ -1,92 +1,25 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 
-var cps;
-var asyncRunner;
-var next;
-
 let loadContext = Cc["@mozilla.org/loadcontext;1"].
                     createInstance(Ci.nsILoadContext);
 let privateLoadContext = Cc["@mozilla.org/privateloadcontext;1"].
                            createInstance(Ci.nsILoadContext);
 
-(function init() {
-  // There has to be a profile directory before the CPS service is gotten.
-  do_get_profile();
-})();
-
-function runAsyncTests(tests, dontResetBefore = false) {
-  do_test_pending();
-
-  cps = Cc["@mozilla.org/content-pref/service;1"].
-        getService(Ci.nsIContentPrefService2);
+// There has to be a profile directory before the CPS service is gotten.
+do_get_profile();
+let cps = Cc["@mozilla.org/content-pref/service;1"].
+          getService(Ci.nsIContentPrefService2);
 
-  let s = {};
-  ChromeUtils.import("resource://test/AsyncRunner.jsm", s);
-  asyncRunner = new s.AsyncRunner({
-    done: do_test_finished,
-    error(err) {
-      // xpcshell test functions like equal throw NS_ERROR_ABORT on
-      // failure.  Ignore those and catch only uncaught exceptions.
-      if (err !== Cr.NS_ERROR_ABORT) {
-        if (err.stack) {
-          err = err + "\n\nTraceback (most recent call first):\n" + err.stack +
-                      "\nUseless do_throw stack:";
-        }
-        do_throw(err);
-      }
-    },
-    consoleError(scriptErr) {
-      // Previously, this code checked for console errors related to the test,
-      // and treated them as failures. This was problematic, because our current
-      // very-broken exception reporting machinery in XPCWrappedJSClass reports
-      // errors to the console even if there's actually JS on the stack above
-      // that will catch them. And a lot of the tests here intentionally trigger
-      // error conditions on the JS-implemented XPCOM component (see erroneous()
-      // in test_getSubdomains.js, for example). In the old world, we got lucky,
-      // and the errors were never reported to the console due to happenstantial
-      // JSContext reasons that aren't really worth going into.
-      //
-      // So. We make sure to dump this stuff so that it shows up in the logs, but
-      // don't turn them into duplicate failures of the exception that was already
-      // propagated to the caller.
-      dump("AsyncRunner.jsm observed console error: " + scriptErr + "\n");
-    }
-  });
-
-  next = asyncRunner.next.bind(asyncRunner);
-
-  registerCleanupFunction(function() {
-    asyncRunner.destroy();
-    asyncRunner = null;
-  });
-
-  tests.forEach(function(test) {
-    function* gen() {
-      info("Running " + test.name);
-      yield test();
-      yield reset();
-    }
-    asyncRunner.appendIterator(gen());
-  });
-
-  // reset() ends up calling asyncRunner.next(), starting the tests.
-  if (dontResetBefore) {
-    next();
-  } else {
-    reset();
-  }
-}
-
-function makeCallback(callbacks, success = null) {
+function makeCallback(resolve, callbacks, success = null) {
   callbacks = callbacks || {};
   if (!callbacks.handleError) {
     callbacks.handleError = function(error) {
       do_throw("handleError call was not expected, error: " + error);
     };
   }
   if (!callbacks.handleResult) {
     callbacks.handleResult = function() {
@@ -94,148 +27,132 @@ function makeCallback(callbacks, success
     };
   }
   if (!callbacks.handleCompletion)
     callbacks.handleCompletion = function(reason) {
       equal(reason, Ci.nsIContentPrefCallback2.COMPLETE_OK);
       if (success) {
         success();
       } else {
-        next();
+        resolve();
       }
     };
   return callbacks;
 }
 
-function do_check_throws(fn) {
+async function do_check_throws(fn) {
   let threw = false;
   try {
-    fn();
+    await fn();
   } catch (err) {
     threw = true;
   }
   ok(threw);
 }
 
 function sendMessage(msg, callback) {
   let obj = callback || {};
   let ref = Cu.getWeakReference(obj);
   cps.QueryInterface(Ci.nsIObserver).observe(ref, "test:" + msg, null);
   return "value" in obj ? obj.value : undefined;
 }
 
 function reset() {
-  sendMessage("reset", next);
+  return new Promise(resolve => {
+    sendMessage("reset", resolve);
+  });
 }
 
 function setWithDate(group, name, val, timestamp, context) {
-  function updateDate() {
-    let db = sendMessage("db");
-    let stmt = db.createAsyncStatement(`
-      UPDATE prefs SET timestamp = :timestamp
+  return new Promise(resolve => {
+    async function updateDate() {
+      let conn = await sendMessage("db");
+      await conn.execute(`
+        UPDATE prefs SET timestamp = :timestamp
+        WHERE
+          settingID = (SELECT id FROM settings WHERE name = :name)
+          AND groupID = (SELECT id FROM groups WHERE name = :group)
+      `, {name, group, timestamp: timestamp / 1000});
+
+      resolve();
+    }
+
+    cps.set(group, name, val, context, makeCallback(null, null, updateDate));
+  });
+}
+
+async function getDate(group, name, context) {
+  let conn = await sendMessage("db");
+  let [result] = await conn.execute(`
+      SELECT timestamp FROM prefs
       WHERE
         settingID = (SELECT id FROM settings WHERE name = :name)
         AND groupID = (SELECT id FROM groups WHERE name = :group)
-    `);
-    stmt.params.timestamp = timestamp / 1000;
-    stmt.params.name = name;
-    stmt.params.group = group;
-
-    stmt.executeAsync({
-      handleCompletion(reason) {
-        next();
-      },
-      handleError(err) {
-        do_throw(err);
-      }
-    });
-    stmt.finalize();
-  }
-
-  cps.set(group, name, val, context, makeCallback(null, updateDate));
-}
+  `, {name, group});
 
-function getDate(group, name, context) {
-  let db = sendMessage("db");
-  let stmt = db.createAsyncStatement(`
-    SELECT timestamp FROM prefs
-    WHERE
-      settingID = (SELECT id FROM settings WHERE name = :name)
-      AND groupID = (SELECT id FROM groups WHERE name = :group)
-  `);
-  stmt.params.name = name;
-  stmt.params.group = group;
-
-  let res;
-  stmt.executeAsync({
-    handleResult(results) {
-      let row = results.getNextRow();
-      res = row.getResultByName("timestamp");
-    },
-    handleCompletion(reason) {
-      next(res * 1000);
-    },
-    handleError(err) {
-      do_throw(err);
-    }
-  });
-  stmt.finalize();
+  return result.getResultByName("timestamp") * 1000;
 }
 
 function set(group, name, val, context) {
-  cps.set(group, name, val, context, makeCallback());
+  return new Promise(resolve => {
+    cps.set(group, name, val, context, makeCallback(resolve));
+  });
 }
 
 function setGlobal(name, val, context) {
-  cps.setGlobal(name, val, context, makeCallback());
+  return new Promise(resolve => {
+    cps.setGlobal(name, val, context, makeCallback(resolve));
+  });
 }
 
 function prefOK(actual, expected, strict) {
   ok(actual instanceof Ci.nsIContentPref);
   equal(actual.domain, expected.domain);
   equal(actual.name, expected.name);
   if (strict)
     strictEqual(actual.value, expected.value);
   else
     equal(actual.value, expected.value);
 }
 
-function* getOK(args, expectedVal, expectedGroup, strict) {
+async function getOK(args, expectedVal, expectedGroup, strict) {
   if (args.length == 2)
     args.push(undefined);
   let expectedPrefs = expectedVal === undefined ? [] :
                       [{ domain: expectedGroup || args[0],
                          name: args[1],
                          value: expectedVal }];
-  yield getOKEx("getByDomainAndName", args, expectedPrefs, strict);
+  await getOKEx("getByDomainAndName", args, expectedPrefs, strict);
 }
 
-function* getSubdomainsOK(args, expectedGroupValPairs) {
+async function getSubdomainsOK(args, expectedGroupValPairs) {
   if (args.length == 2)
     args.push(undefined);
   let expectedPrefs = expectedGroupValPairs.map(function([group, val]) {
     return { domain: group, name: args[1], value: val };
   });
-  yield getOKEx("getBySubdomainAndName", args, expectedPrefs);
+  await getOKEx("getBySubdomainAndName", args, expectedPrefs);
 }
 
-function* getGlobalOK(args, expectedVal) {
+async function getGlobalOK(args, expectedVal) {
   if (args.length == 1)
     args.push(undefined);
   let expectedPrefs = expectedVal === undefined ? [] :
                       [{ domain: null, name: args[0], value: expectedVal }];
-  yield getOKEx("getGlobal", args, expectedPrefs);
+  await getOKEx("getGlobal", args, expectedPrefs);
 }
 
-function* getOKEx(methodName, args, expectedPrefs, strict, context) {
+async function getOKEx(methodName, args, expectedPrefs, strict, context) {
   let actualPrefs = [];
-  args.push(makeCallback({
-    handleResult: pref => actualPrefs.push(pref)
-  }));
-  yield cps[methodName].apply(cps, args);
+  await new Promise(resolve => {
+    args.push(makeCallback(resolve, {
+      handleResult: pref => actualPrefs.push(pref)
+    }));
+    cps[methodName].apply(cps, args);
+  });
   arraysOfArraysOK([actualPrefs], [expectedPrefs], function(actual, expected) {
     prefOK(actual, expected, strict);
   });
 }
 
 function getCachedOK(args, expectedIsCached, expectedVal, expectedGroup,
                      strict) {
   if (args.length == 2)
@@ -296,19 +213,19 @@ function arraysOK(actual, expected, cmp)
 
 function arraysOfArraysOK(actual, expected, cmp) {
   cmp = cmp || equal;
   arraysOK(actual, expected, function(act, exp) {
     arraysOK(act, exp, cmp);
   });
 }
 
-function dbOK(expectedRows) {
-  let db = sendMessage("db");
-  let stmt = db.createAsyncStatement(`
+async function dbOK(expectedRows) {
+  let conn = await sendMessage("db");
+  let stmt = `
     SELECT groups.name AS grp, settings.name AS name, prefs.value AS value
     FROM prefs
     LEFT JOIN groups ON groups.id = prefs.groupID
     LEFT JOIN settings ON settings.id = prefs.settingID
     UNION
 
     /*
       These second two SELECTs get the rows of the groups and settings tables
@@ -327,77 +244,78 @@ function dbOK(expectedRows) {
     FROM settings
     WHERE id NOT IN (
       SELECT DISTINCT settingID
       FROM prefs
       WHERE settingID NOTNULL
     )
 
     ORDER BY value ASC, grp ASC, name ASC
-  `);
+  `;
 
-  let actualRows = [];
   let cols = ["grp", "name", "value"];
 
-  db.executeAsync([stmt], 1, {
-    handleCompletion(reason) {
-      arraysOfArraysOK(actualRows, expectedRows);
-      next();
-    },
-    handleResult(results) {
-      let row = null;
-      while ((row = results.getNextRow())) {
-        actualRows.push(cols.map(c => row.getResultByName(c)));
-      }
-    },
-    handleError(err) {
-      do_throw(err);
-    }
-  });
-  stmt.finalize();
+  let actualRows = (await conn.execute(stmt)).map(row => (cols.map(c => row.getResultByName(c))));
+  arraysOfArraysOK(actualRows, expectedRows);
 }
 
 function on(event, names, dontRemove) {
+  return onEx(event, names, dontRemove).promise;
+}
+
+function onEx(event, names, dontRemove) {
   let args = {
     reset() {
       for (let prop in this) {
         if (Array.isArray(this[prop]))
           this[prop].splice(0, this[prop].length);
       }
     },
   };
 
   let observers = {};
+  let deferred = null;
+  let triggered = false;
 
   names.forEach(function(name) {
     let obs = {};
     ["onContentPrefSet", "onContentPrefRemoved"].forEach(function(meth) {
-      obs[meth] = () => do_throw(meth + " should not be called");
+      obs[meth] = () => do_throw(meth + " should not be called for " + name);
     });
     obs["onContentPref" + event] = function() {
       args[name].push(Array.slice(arguments));
+
+      if (!triggered) {
+        triggered = true;
+        executeSoon(function() {
+          if (!dontRemove)
+            names.forEach(n => cps.removeObserverForName(n, observers[n]));
+          deferred.resolve(args);
+        });
+      }
     };
     observers[name] = obs;
     args[name] = [];
     args[name].observer = obs;
     cps.addObserverForName(name, obs);
   });
 
-  executeSoon(function() {
-    if (!dontRemove)
-      names.forEach(n => cps.removeObserverForName(n, observers[n]));
-    next(args);
-  });
+  return {
+    observers,
+    promise: new Promise(resolve => {
+      deferred = {resolve};
+    }),
+  };
 }
 
-function schemaVersionIs(expectedVersion) {
-  let db = sendMessage("db");
-  equal(db.schemaVersion, expectedVersion);
+async function schemaVersionIs(expectedVersion) {
+  let db = await sendMessage("db");
+  equal(await db.getSchemaVersion(), expectedVersion);
 }
 
 function wait() {
-  executeSoon(next);
+  return new Promise(resolve => executeSoon(resolve));
 }
 
 function observerArgsOK(actualArgs, expectedArgs) {
   notEqual(actualArgs, undefined);
   arraysOfArraysOK(actualArgs, expectedArgs);
 }
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_getCached.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_getCached.js
@@ -1,95 +1,97 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-var tests = [
+add_task(async function nonexistent() {
+  getCachedOK(["a.com", "foo"], false, undefined);
+  getCachedGlobalOK(["foo"], false, undefined);
+  await reset();
+});
 
-  function* nonexistent() {
-    getCachedOK(["a.com", "foo"], false, undefined);
-    getCachedGlobalOK(["foo"], false, undefined);
-    yield true;
-  },
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["http://a.com/huh", "foo"], true, 1, "a.com");
+  await reset();
+});
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["http://a.com/huh", "foo"], true, 1, "a.com");
-  },
-
-  function* names() {
-    yield set("a.com", "foo", 1);
-    getCachedOK(["a.com", "foo"], true, 1);
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  getCachedOK(["a.com", "foo"], true, 1);
 
-    yield set("a.com", "bar", 2);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["a.com", "bar"], true, 2);
+  await set("a.com", "bar", 2);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["a.com", "bar"], true, 2);
 
-    yield setGlobal("foo", 3);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["a.com", "bar"], true, 2);
-    getCachedGlobalOK(["foo"], true, 3);
+  await setGlobal("foo", 3);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["a.com", "bar"], true, 2);
+  getCachedGlobalOK(["foo"], true, 3);
 
-    yield setGlobal("bar", 4);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["a.com", "bar"], true, 2);
-    getCachedGlobalOK(["foo"], true, 3);
-    getCachedGlobalOK(["bar"], true, 4);
-  },
+  await setGlobal("bar", 4);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["a.com", "bar"], true, 2);
+  getCachedGlobalOK(["foo"], true, 3);
+  getCachedGlobalOK(["bar"], true, 4);
+  await reset();
+});
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["b.a.com", "foo"], true, 2);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["b.a.com", "foo"], true, 2);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    getCachedOK(["a.com", "foo", context], true, 6);
-    getCachedOK(["a.com", "bar", context], true, 2);
-    getCachedGlobalOK(["foo", context], true, 7);
-    getCachedGlobalOK(["bar", context], true, 4);
-    getCachedOK(["b.com", "foo", context], true, 5);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  getCachedOK(["a.com", "foo", context], true, 6);
+  getCachedOK(["a.com", "bar", context], true, 2);
+  getCachedGlobalOK(["foo", context], true, 7);
+  getCachedGlobalOK(["bar", context], true, 4);
+  getCachedOK(["b.com", "foo", context], true, 5);
 
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["a.com", "bar"], true, 2);
-    getCachedGlobalOK(["foo"], true, 3);
-    getCachedGlobalOK(["bar"], true, 4);
-    getCachedOK(["b.com", "foo"], true, 5);
-  },
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["a.com", "bar"], true, 2);
+  getCachedGlobalOK(["foo"], true, 3);
+  getCachedGlobalOK(["bar"], true, 4);
+  getCachedOK(["b.com", "foo"], true, 5);
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.getCachedByDomainAndName(null, "foo", null));
-    do_check_throws(() => cps.getCachedByDomainAndName("", "foo", null));
-    do_check_throws(() => cps.getCachedByDomainAndName("a.com", "", null));
-    do_check_throws(() => cps.getCachedByDomainAndName("a.com", null, null));
-    do_check_throws(() => cps.getCachedGlobal("", null));
-    do_check_throws(() => cps.getCachedGlobal(null, null));
-    yield true;
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.getCachedByDomainAndName(null, "foo", null));
+  do_check_throws(() => cps.getCachedByDomainAndName("", "foo", null));
+  do_check_throws(() => cps.getCachedByDomainAndName("a.com", "", null));
+  do_check_throws(() => cps.getCachedByDomainAndName("a.com", null, null));
+  do_check_throws(() => cps.getCachedGlobal("", null));
+  do_check_throws(() => cps.getCachedGlobal(null, null));
+  await reset();
+});
 
-  function* casts() {
-    // SQLite casts booleans to integers.  This makes sure the values stored in
-    // the cache are the same as the casted values in the database.
+add_task(async function casts() {
+  // SQLite casts booleans to integers.  This makes sure the values stored in
+  // the cache are the same as the casted values in the database.
 
-    yield set("a.com", "foo", false);
-    yield getOK(["a.com", "foo"], 0, "a.com", true);
-    getCachedOK(["a.com", "foo"], true, 0, "a.com", true);
+  await set("a.com", "foo", false);
+  await getOK(["a.com", "foo"], 0, "a.com", true);
+  getCachedOK(["a.com", "foo"], true, 0, "a.com", true);
 
-    yield set("a.com", "bar", true);
-    yield getOK(["a.com", "bar"], 1, "a.com", true);
-    getCachedOK(["a.com", "bar"], true, 1, "a.com", true);
-  },
-];
+  await set("a.com", "bar", true);
+  await getOK(["a.com", "bar"], 1, "a.com", true);
+  getCachedOK(["a.com", "bar"], true, 1, "a.com", true);
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_getCachedSubdomains.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_getCachedSubdomains.js
@@ -1,186 +1,193 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
-
-var tests = [
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-  function* nonexistent() {
-    getCachedSubdomainsOK(["a.com", "foo"], []);
-    yield true;
-  },
+add_task(async function nonexistent() {
+  getCachedSubdomainsOK(["a.com", "foo"], []);
+  await reset();
+});
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    getCachedSubdomainsOK(["http://a.com/huh", "foo"], [["a.com", 1]]);
-  },
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  getCachedSubdomainsOK(["http://a.com/huh", "foo"], [["a.com", 1]]);
+  await reset();
+});
 
-  function* names() {
-    yield set("a.com", "foo", 1);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
 
-    yield set("a.com", "bar", 2);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  await set("a.com", "bar", 2);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
 
-    yield setGlobal("foo", 3);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-    getCachedGlobalOK(["foo"], true, 3);
+  await setGlobal("foo", 3);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  getCachedGlobalOK(["foo"], true, 3);
 
-    yield setGlobal("bar", 4);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-    getCachedGlobalOK(["foo"], true, 3);
-    getCachedGlobalOK(["bar"], true, 4);
-  },
+  await setGlobal("bar", 4);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  getCachedGlobalOK(["foo"], true, 3);
+  getCachedGlobalOK(["bar"], true, 4);
+  await reset();
+});
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1], ["b.a.com", 2]]);
-    getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1], ["b.a.com", 2]]);
+  getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
+  await reset();
+});
+
+add_task(async function populateViaGet() {
+  await new Promise(resolve => cps.getByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
 
-  function* populateViaGet() {
-    yield cps.getByDomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  await new Promise(resolve => cps.getGlobal("foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
+  await reset();
+});
 
-    yield cps.getGlobal("foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
-  },
-
-  function* populateViaGetSubdomains() {
-    yield cps.getBySubdomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-  },
+add_task(async function populateViaGetSubdomains() {
+  await new Promise(resolve => cps.getBySubdomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  await reset();
+});
 
-  function* populateViaRemove() {
-    yield cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+add_task(async function populateViaRemove() {
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
 
-    yield cps.removeBySubdomainAndName("b.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  await new Promise(resolve => cps.removeBySubdomainAndName("b.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
 
-    yield cps.removeGlobal("foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
+  await new Promise(resolve => cps.removeGlobal("foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
 
-    yield set("a.com", "foo", 1);
-    yield cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
+  await set("a.com", "foo", 1);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
 
-    yield set("a.com", "foo", 2);
-    yield set("b.a.com", "foo", 3);
-    yield cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"],
-                          [["a.com", undefined], ["b.a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
-    getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", undefined]]);
+  await set("a.com", "foo", 2);
+  await set("b.a.com", "foo", 3);
+  await new Promise(resolve => cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"],
+                        [["a.com", undefined], ["b.a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
+  getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", undefined]]);
 
-    yield setGlobal("foo", 4);
-    yield cps.removeGlobal("foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"],
-                          [["a.com", undefined], ["b.a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
-    getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", undefined]]);
-  },
+  await setGlobal("foo", 4);
+  await new Promise(resolve => cps.removeGlobal("foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"],
+                        [["a.com", undefined], ["b.a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
+  getCachedSubdomainsOK(["b.a.com", "foo"], [["b.a.com", undefined]]);
+  await reset();
+});
 
-  function* populateViaRemoveByDomain() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield set("b.a.com", "foo", 3);
-    yield set("b.a.com", "bar", 4);
-    yield cps.removeByDomain("a.com", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"],
-                          [["a.com", undefined], ["b.a.com", 3]]);
-    getCachedSubdomainsOK(["a.com", "bar"],
-                          [["a.com", undefined], ["b.a.com", 4]]);
+add_task(async function populateViaRemoveByDomain() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await set("b.a.com", "foo", 3);
+  await set("b.a.com", "bar", 4);
+  await new Promise(resolve => cps.removeByDomain("a.com", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"],
+                        [["a.com", undefined], ["b.a.com", 3]]);
+  getCachedSubdomainsOK(["a.com", "bar"],
+                        [["a.com", undefined], ["b.a.com", 4]]);
 
-    yield set("a.com", "foo", 5);
-    yield set("a.com", "bar", 6);
-    yield cps.removeBySubdomain("a.com", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"],
-                          [["a.com", undefined], ["b.a.com", undefined]]);
-    getCachedSubdomainsOK(["a.com", "bar"],
-                          [["a.com", undefined], ["b.a.com", undefined]]);
+  await set("a.com", "foo", 5);
+  await set("a.com", "bar", 6);
+  await new Promise(resolve => cps.removeBySubdomain("a.com", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"],
+                        [["a.com", undefined], ["b.a.com", undefined]]);
+  getCachedSubdomainsOK(["a.com", "bar"],
+                        [["a.com", undefined], ["b.a.com", undefined]]);
 
-    yield setGlobal("foo", 7);
-    yield setGlobal("bar", 8);
-    yield cps.removeAllGlobals(null, makeCallback());
-    getCachedGlobalOK(["foo"], true, undefined);
-    getCachedGlobalOK(["bar"], true, undefined);
-  },
+  await setGlobal("foo", 7);
+  await setGlobal("bar", 8);
+  await new Promise(resolve => cps.removeAllGlobals(null, makeCallback(resolve)));
+  getCachedGlobalOK(["foo"], true, undefined);
+  getCachedGlobalOK(["bar"], true, undefined);
+  await reset();
+});
 
-  function* populateViaRemoveAllDomains() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield set("b.com", "foo", 3);
-    yield set("b.com", "bar", 4);
-    yield cps.removeAllDomains(null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
-    getCachedSubdomainsOK(["b.com", "bar"], [["b.com", undefined]]);
-  },
+add_task(async function populateViaRemoveAllDomains() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await set("b.com", "foo", 3);
+  await set("b.com", "bar", 4);
+  await new Promise(resolve => cps.removeAllDomains(null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", undefined]]);
+  getCachedSubdomainsOK(["b.com", "bar"], [["b.com", undefined]]);
+  await reset();
+});
 
-  function* populateViaRemoveByName() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield cps.removeByName("foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-    getCachedGlobalOK(["foo"], true, undefined);
-    getCachedGlobalOK(["bar"], true, 4);
+add_task(async function populateViaRemoveByName() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await new Promise(resolve => cps.removeByName("foo", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  getCachedGlobalOK(["foo"], true, undefined);
+  getCachedGlobalOK(["bar"], true, 4);
 
-    yield cps.removeByName("bar", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", undefined]]);
-    getCachedGlobalOK(["foo"], true, undefined);
-    getCachedGlobalOK(["bar"], true, undefined);
-  },
-
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+  await new Promise(resolve => cps.removeByName("bar", null, makeCallback(resolve)));
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", undefined]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", undefined]]);
+  getCachedGlobalOK(["foo"], true, undefined);
+  getCachedGlobalOK(["bar"], true, undefined);
+  await reset();
+});
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    getCachedSubdomainsOK(["a.com", "foo", context], [["a.com", 6]]);
-    getCachedSubdomainsOK(["a.com", "bar", context], [["a.com", 2]]);
-    getCachedGlobalOK(["foo", context], true, 7);
-    getCachedGlobalOK(["bar", context], true, 4);
-    getCachedSubdomainsOK(["b.com", "foo", context], [["b.com", 5]]);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  getCachedSubdomainsOK(["a.com", "foo", context], [["a.com", 6]]);
+  getCachedSubdomainsOK(["a.com", "bar", context], [["a.com", 2]]);
+  getCachedGlobalOK(["foo", context], true, 7);
+  getCachedGlobalOK(["bar", context], true, 4);
+  getCachedSubdomainsOK(["b.com", "foo", context], [["b.com", 5]]);
 
-    getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-    getCachedGlobalOK(["foo"], true, 3);
-    getCachedGlobalOK(["bar"], true, 4);
-    getCachedSubdomainsOK(["b.com", "foo"], [["b.com", 5]]);
-  },
+  getCachedSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  getCachedSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  getCachedGlobalOK(["foo"], true, 3);
+  getCachedGlobalOK(["bar"], true, 4);
+  getCachedSubdomainsOK(["b.com", "foo"], [["b.com", 5]]);
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.getCachedBySubdomainAndName(null, "foo", null));
-    do_check_throws(() => cps.getCachedBySubdomainAndName("", "foo", null));
-    do_check_throws(() => cps.getCachedBySubdomainAndName("a.com", "", null));
-    do_check_throws(() => cps.getCachedBySubdomainAndName("a.com", null, null));
-    yield true;
-  },
-];
+add_task(async function erroneous() {
+  do_check_throws(() => cps.getCachedBySubdomainAndName(null, "foo", null));
+  do_check_throws(() => cps.getCachedBySubdomainAndName("", "foo", null));
+  do_check_throws(() => cps.getCachedBySubdomainAndName("a.com", "", null));
+  do_check_throws(() => cps.getCachedBySubdomainAndName("a.com", null, null));
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_getSubdomains.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_getSubdomains.js
@@ -1,68 +1,70 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-var tests = [
-
-  function* get_nonexistent() {
-    yield getSubdomainsOK(["a.com", "foo"], []);
-  },
+add_task(async function get_nonexistent() {
+  await getSubdomainsOK(["a.com", "foo"], []);
+  await reset();
+});
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    yield getSubdomainsOK(["http://a.com/huh", "foo"], [["a.com", 1]]);
-  },
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  await getSubdomainsOK(["http://a.com/huh", "foo"], [["a.com", 1]]);
+  await reset();
+});
 
-  function* names() {
-    yield set("a.com", "foo", 1);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
 
-    yield set("a.com", "bar", 2);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    yield getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  await set("a.com", "bar", 2);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  await getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
 
-    yield setGlobal("foo", 3);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    yield getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-  },
+  await setGlobal("foo", 3);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  await getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  await reset();
+});
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1], ["b.a.com", 2]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1], ["b.a.com", 2]]);
+  await getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    yield getSubdomainsOK(["a.com", "foo", context], [["a.com", 6]]);
-    yield getSubdomainsOK(["a.com", "bar", context], [["a.com", 2]]);
-    yield getSubdomainsOK(["b.com", "foo", context], [["b.com", 5]]);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  await getSubdomainsOK(["a.com", "foo", context], [["a.com", 6]]);
+  await getSubdomainsOK(["a.com", "bar", context], [["a.com", 2]]);
+  await getSubdomainsOK(["b.com", "foo", context], [["b.com", 5]]);
 
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
-    yield getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
-    yield getSubdomainsOK(["b.com", "foo"], [["b.com", 5]]);
-  },
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 1]]);
+  await getSubdomainsOK(["a.com", "bar"], [["a.com", 2]]);
+  await getSubdomainsOK(["b.com", "foo"], [["b.com", 5]]);
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.getBySubdomainAndName(null, "foo", null, {}));
-    do_check_throws(() => cps.getBySubdomainAndName("", "foo", null, {}));
-    do_check_throws(() => cps.getBySubdomainAndName("a.com", "", null, {}));
-    do_check_throws(() => cps.getBySubdomainAndName("a.com", null, null, {}));
-    do_check_throws(() => cps.getBySubdomainAndName("a.com", "foo", null, null));
-    yield true;
-  },
-];
+add_task(async function erroneous() {
+  do_check_throws(() => cps.getBySubdomainAndName(null, "foo", null, {}));
+  do_check_throws(() => cps.getBySubdomainAndName("", "foo", null, {}));
+  do_check_throws(() => cps.getBySubdomainAndName("a.com", "", null, {}));
+  do_check_throws(() => cps.getBySubdomainAndName("a.com", null, null, {}));
+  do_check_throws(() => cps.getBySubdomainAndName("a.com", "foo", null, null));
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_migrationToSchema4.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_migrationToSchema4.js
@@ -35,43 +35,40 @@ function prepareVersion3Schema(callback)
   equal(dbConnection.schemaVersion, 0);
 
   dbConnection.executeSimpleSQL(schema_version3);
   dbConnection.schemaVersion = 3;
 
   dbConnection.close();
 }
 
-function run_test() {
+add_task(async function resetBeforeTests() {
   prepareVersion3Schema();
-  runAsyncTests(tests, true);
-}
-
+});
 
 // WARNING: Database will reset after every test. This limitation comes from
 // the fact that we ContentPrefService constructor is run only once per test file
 // and so migration will be run only once.
-var tests = [
-  function* testMigration() {
-    // Test migrated db content.
-    schemaVersionIs(4);
-    let dbExpectedState = [
-      [null, "zoom-setting", 0.1],
-      ["bar.com", "zoom-setting", 0.3],
-      ["foo.com", "zoom-setting", 0.5],
-      ["foo.com", "dir-setting", "/download/dir"],
-    ];
-    yield dbOK(dbExpectedState);
+add_task(async function testMigration() {
+  // Test migrated db content.
+  await schemaVersionIs(4);
+  let dbExpectedState = [
+    [null, "zoom-setting", 0.1],
+    ["bar.com", "zoom-setting", 0.3],
+    ["foo.com", "zoom-setting", 0.5],
+    ["foo.com", "dir-setting", "/download/dir"],
+  ];
+  await dbOK(dbExpectedState);
 
-    // Migrated fields should have timestamp set to 0.
-    yield cps.removeAllDomainsSince(1000, null, makeCallback());
-    yield dbOK(dbExpectedState);
+  // Migrated fields should have timestamp set to 0.
+  await new Promise(resolve => cps.removeAllDomainsSince(1000, null, makeCallback(resolve)));
+  await dbOK(dbExpectedState);
 
-    yield cps.removeAllDomainsSince(0, null, makeCallback());
-    yield dbOK([[null, "zoom-setting", 0.1]]);
+  await new Promise(resolve => cps.removeAllDomainsSince(0, null, makeCallback(resolve)));
+  await dbOK([[null, "zoom-setting", 0.1]]);
 
-    // Test that dates are present after migration (column is added).
-    const timestamp = 1234;
-    yield setWithDate("a.com", "pref-name", "val", timestamp);
-    let actualTimestamp = yield getDate("a.com", "pref-name");
-    equal(actualTimestamp, timestamp);
-  }
-];
+  // Test that dates are present after migration (column is added).
+  const timestamp = 1234;
+  await setWithDate("a.com", "pref-name", "val", timestamp);
+  let actualTimestamp = await getDate("a.com", "pref-name");
+  equal(actualTimestamp, timestamp);
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_observers.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_observers.js
@@ -1,180 +1,211 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 let global = this;
 
-function run_test() {
-  var allTests = [];
-  for (var i = 0; i < tests.length; i++) {
-    // Generate two wrappers of each test function that invoke the original test with an
-    // appropriate privacy context.
-    /* eslint-disable no-eval */
-    var pub = eval("var f = function* " + tests[i].name + "() { yield tests[" + i + "](privateLoadContext); }; f");
-    var priv = eval("var f = function* " + tests[i].name + "_private() { yield tests[" + i + "](privateLoadContext); }; f");
-    /* eslint-enable no-eval */
-    allTests.push(pub);
-    allTests.push(priv);
-  }
-  allTests = allTests.concat(specialTests);
-  runAsyncTests(allTests);
+add_task(async function resetBeforeTests() {
+  await reset();
+});
+
+function raceWithIdleDispatch(promise) {
+  return Promise.race([promise, new Promise(resolve => {
+    Services.tm.idleDispatchToMainThread(() => resolve(null));
+  })]);
 }
 
 var tests = [
 
-  function* observerForName_set(context) {
-    yield set("a.com", "foo", 1, context);
-    let args = yield on("Set", ["foo", null, "bar"]);
+  async function observerForName_set(context) {
+    let argsPromise;
+    argsPromise = on("Set", ["foo", null, "bar"]);
+    await set("a.com", "foo", 1, context);
+    let args = await argsPromise;
     observerArgsOK(args.foo, [["a.com", "foo", 1, context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [["a.com", "foo", 1, context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
 
-    yield setGlobal("foo", 2, context);
-    args = yield on("Set", ["foo", null, "bar"]);
+    argsPromise = on("Set", ["foo", null, "bar"]);
+    await setGlobal("foo", 2, context);
+    args = await argsPromise;
     observerArgsOK(args.foo, [[null, "foo", 2, context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [[null, "foo", 2, context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
+    await reset();
   },
 
-  function* observerForName_remove(context) {
-    yield set("a.com", "foo", 1, context);
-    yield setGlobal("foo", 2, context);
+  async function observerForName_remove(context) {
+    let argsPromise;
+    await set("a.com", "foo", 1, context);
+    await setGlobal("foo", 2, context);
 
-    yield cps.removeByDomainAndName("a.com", "bogus", context, makeCallback());
-    let args = yield on("Removed", ["foo", null, "bar"]);
-    observerArgsOK(args.foo, []);
-    observerArgsOK(args.null, []);
-    observerArgsOK(args.bar, []);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeByDomainAndName("a.com", "bogus", context, makeCallback(resolve)));
+    let args = await raceWithIdleDispatch(argsPromise);
+    strictEqual(args, null);
 
-    yield cps.removeByDomainAndName("a.com", "foo", context, makeCallback());
-    args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", context, makeCallback(resolve)));
+    args = await argsPromise;
     observerArgsOK(args.foo, [["a.com", "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [["a.com", "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
 
-    yield cps.removeGlobal("foo", context, makeCallback());
-    args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeGlobal("foo", context, makeCallback(resolve)));
+    args = await argsPromise;
     observerArgsOK(args.foo, [[null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [[null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
+    await reset();
   },
 
-  function* observerForName_removeByDomain(context) {
-    yield set("a.com", "foo", 1, context);
-    yield set("b.a.com", "bar", 2, context);
-    yield setGlobal("foo", 3, context);
+  async function observerForName_removeByDomain(context) {
+    let argsPromise;
+    await set("a.com", "foo", 1, context);
+    await set("b.a.com", "bar", 2, context);
+    await setGlobal("foo", 3, context);
 
-    yield cps.removeByDomain("bogus", context, makeCallback());
-    let args = yield on("Removed", ["foo", null, "bar"]);
-    observerArgsOK(args.foo, []);
-    observerArgsOK(args.null, []);
-    observerArgsOK(args.bar, []);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeByDomain("bogus", context, makeCallback(resolve)));
+    let args = await raceWithIdleDispatch(argsPromise);
+    strictEqual(args, null);
 
-    yield cps.removeBySubdomain("a.com", context, makeCallback());
-    args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeBySubdomain("a.com", context, makeCallback(resolve)));
+    args = await argsPromise;
     observerArgsOK(args.foo, [["a.com", "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [["a.com", "foo", context.usePrivateBrowsing], ["b.a.com", "bar", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, [["b.a.com", "bar", context.usePrivateBrowsing]]);
 
-    yield cps.removeAllGlobals(context, makeCallback());
-    args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeAllGlobals(context, makeCallback(resolve)));
+    args = await argsPromise;
     observerArgsOK(args.foo, [[null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [[null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
+    await reset();
   },
 
-  function* observerForName_removeAllDomains(context) {
-    yield set("a.com", "foo", 1, context);
-    yield setGlobal("foo", 2, context);
-    yield set("b.com", "bar", 3, context);
+  async function observerForName_removeAllDomains(context) {
+    let argsPromise;
+    await set("a.com", "foo", 1, context);
+    await setGlobal("foo", 2, context);
+    await set("b.com", "bar", 3, context);
 
-    yield cps.removeAllDomains(context, makeCallback());
-    let args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeAllDomains(context, makeCallback(resolve)));
+    let args = await argsPromise;
     observerArgsOK(args.foo, [["a.com", "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [["a.com", "foo", context.usePrivateBrowsing], ["b.com", "bar", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, [["b.com", "bar", context.usePrivateBrowsing]]);
+    await reset();
   },
 
-  function* observerForName_removeByName(context) {
-    yield set("a.com", "foo", 1, context);
-    yield set("a.com", "bar", 2, context);
-    yield setGlobal("foo", 3, context);
+  async function observerForName_removeByName(context) {
+    let argsPromise;
+    await set("a.com", "foo", 1, context);
+    await set("a.com", "bar", 2, context);
+    await setGlobal("foo", 3, context);
 
-    yield cps.removeByName("bogus", context, makeCallback());
-    let args = yield on("Removed", ["foo", null, "bar"]);
-    observerArgsOK(args.foo, []);
-    observerArgsOK(args.null, []);
-    observerArgsOK(args.bar, []);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeByName("bogus", context, makeCallback(resolve)));
+    let args = await raceWithIdleDispatch(argsPromise);
+    strictEqual(args, null);
 
-    yield cps.removeByName("foo", context, makeCallback());
-    args = yield on("Removed", ["foo", null, "bar"]);
+    argsPromise = on("Removed", ["foo", null, "bar"]);
+    await new Promise(resolve => cps.removeByName("foo", context, makeCallback(resolve)));
+    args = await argsPromise;
     observerArgsOK(args.foo, [["a.com", "foo", context.usePrivateBrowsing], [null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.null, [["a.com", "foo", context.usePrivateBrowsing], [null, "foo", context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
+    await reset();
   },
 
-  function* removeObserverForName(context) {
-    let args = yield on("Set", ["foo", null, "bar"], true);
-
-    cps.removeObserverForName("foo", args.foo.observer);
-    yield set("a.com", "foo", 1, context);
-    yield wait();
+  async function removeObserverForName(context) {
+    let {promise, observers} = onEx("Set", ["foo", null, "bar"]);
+    cps.removeObserverForName("foo", observers.foo);
+    await set("a.com", "foo", 1, context);
+    await wait();
+    let args = await promise;
     observerArgsOK(args.foo, []);
     observerArgsOK(args.null, [["a.com", "foo", 1, context.usePrivateBrowsing]]);
     observerArgsOK(args.bar, []);
     args.reset();
 
     cps.removeObserverForName(null, args.null.observer);
-    yield set("a.com", "foo", 2, context);
-    yield wait();
+    await set("a.com", "foo", 2, context);
+    await wait();
     observerArgsOK(args.foo, []);
     observerArgsOK(args.null, []);
     observerArgsOK(args.bar, []);
     args.reset();
+    await reset();
   },
 ];
 
 // These tests are for functionality that doesn't behave the same way in private and public
 // contexts, so the expected results cannot be automatically generated like the previous tests.
 var specialTests = [
-  function* observerForName_removeAllDomainsSince() {
-    yield setWithDate("a.com", "foo", 1, 100, null);
-    yield setWithDate("b.com", "foo", 2, 200, null);
-    yield setWithDate("c.com", "foo", 3, 300, null);
+  async function observerForName_removeAllDomainsSince() {
+    let argsPromise;
+    await setWithDate("a.com", "foo", 1, 100, null);
+    await setWithDate("b.com", "foo", 2, 200, null);
+    await setWithDate("c.com", "foo", 3, 300, null);
 
-    yield setWithDate("a.com", "bar", 1, 0, null);
-    yield setWithDate("b.com", "bar", 2, 100, null);
-    yield setWithDate("c.com", "bar", 3, 200, null);
-    yield setGlobal("foo", 2, null);
+    await setWithDate("a.com", "bar", 1, 0, null);
+    await setWithDate("b.com", "bar", 2, 100, null);
+    await setWithDate("c.com", "bar", 3, 200, null);
+    await setGlobal("foo", 2, null);
 
-    yield cps.removeAllDomainsSince(200, null, makeCallback());
+    argsPromise = on("Removed", ["foo", "bar", null]);
+    await new Promise(resolve => cps.removeAllDomainsSince(200, null, makeCallback(resolve)));
 
-    let args = yield on("Removed", ["foo", "bar", null]);
+    let args = await argsPromise;
 
     observerArgsOK(args.foo, [["b.com", "foo", false], ["c.com", "foo", false]]);
     observerArgsOK(args.bar, [["c.com", "bar", false]]);
     observerArgsOK(args.null, [["b.com", "foo", false], ["c.com", "bar", false], ["c.com", "foo", false]]);
+    await reset();
   },
 
-  function* observerForName_removeAllDomainsSince_private() {
+  async function observerForName_removeAllDomainsSince_private() {
+    let argsPromise;
     let context = privateLoadContext;
-    yield setWithDate("a.com", "foo", 1, 100, context);
-    yield setWithDate("b.com", "foo", 2, 200, context);
-    yield setWithDate("c.com", "foo", 3, 300, context);
+    await setWithDate("a.com", "foo", 1, 100, context);
+    await setWithDate("b.com", "foo", 2, 200, context);
+    await setWithDate("c.com", "foo", 3, 300, context);
 
-    yield setWithDate("a.com", "bar", 1, 0, context);
-    yield setWithDate("b.com", "bar", 2, 100, context);
-    yield setWithDate("c.com", "bar", 3, 200, context);
-    yield setGlobal("foo", 2, context);
+    await setWithDate("a.com", "bar", 1, 0, context);
+    await setWithDate("b.com", "bar", 2, 100, context);
+    await setWithDate("c.com", "bar", 3, 200, context);
+    await setGlobal("foo", 2, context);
 
-    yield cps.removeAllDomainsSince(200, context, makeCallback());
+    argsPromise = on("Removed", ["foo", "bar", null]);
+    await new Promise(resolve => cps.removeAllDomainsSince(200, context, makeCallback(resolve)));
 
-    let args = yield on("Removed", ["foo", "bar", null]);
+    let args = await argsPromise;
 
     observerArgsOK(args.foo, [["a.com", "foo", true], ["b.com", "foo", true], ["c.com", "foo", true]]);
     observerArgsOK(args.bar, [["a.com", "bar", true], ["b.com", "bar", true], ["c.com", "bar", true]]);
     observerArgsOK(args.null, [["a.com", "foo", true], ["a.com", "bar", true],
                                ["b.com", "foo", true], ["b.com", "bar", true],
                                ["c.com", "foo", true], ["c.com", "bar", true]]);
+    await reset();
   },
 ];
+
+for (let i = 0; i < tests.length; i++) {
+  // Generate two wrappers of each test function that invoke the original test with an
+  // appropriate privacy context.
+  /* eslint-disable no-eval */
+  var pub = eval("var f = async function " + tests[i].name + "() { await tests[" + i + "](privateLoadContext); }; f");
+  var priv = eval("var f = async function " + tests[i].name + "_private() { await tests[" + i + "](privateLoadContext); }; f");
+  /* eslint-enable no-eval */
+  add_task(pub);
+  add_task(priv);
+}
+
+for (let test of specialTests) {
+  add_task(test);
+}
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_remove.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_remove.js
@@ -1,222 +1,233 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-var tests = [
+add_task(async function nonexistent() {
+  await set("a.com", "foo", 1);
+  await setGlobal("foo", 2);
 
-  function* nonexistent() {
-    yield set("a.com", "foo", 1);
-    yield setGlobal("foo", 2);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
 
-    yield cps.removeByDomainAndName("a.com", "bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
+  await new Promise(resolve => cps.removeBySubdomainAndName("a.com", "bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
 
-    yield cps.removeBySubdomainAndName("a.com", "bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
+  await new Promise(resolve => cps.removeGlobal("bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
 
-    yield cps.removeGlobal("bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
+  await new Promise(resolve => cps.removeByDomainAndName("bogus", "bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
+  await reset();
+});
 
-    yield cps.removeByDomainAndName("bogus", "bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
-  },
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([]);
+  await getOK(["a.com", "foo"], undefined);
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    yield cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    yield dbOK([]);
-    yield getOK(["a.com", "foo"], undefined);
+  await set("a.com", "foo", 2);
+  await new Promise(resolve => cps.removeByDomainAndName("http://a.com/huh", "foo", null,
+                                                         makeCallback(resolve)));
+  await dbOK([]);
+  await getOK(["a.com", "foo"], undefined);
+  await reset();
+});
 
-    yield set("a.com", "foo", 2);
-    yield cps.removeByDomainAndName("http://a.com/huh", "foo", null,
-                                    makeCallback());
-    yield dbOK([]);
-    yield getOK(["a.com", "foo"], undefined);
-  },
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
 
-  function* names() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "bar", 2],
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
 
-    yield cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    yield dbOK([
-      ["a.com", "bar", 2],
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
+  await new Promise(resolve => cps.removeGlobal("foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "bar", 2],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], 4);
 
-    yield cps.removeGlobal("foo", null, makeCallback());
-    yield dbOK([
-      ["a.com", "bar", 2],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], 4);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "bar", null, makeCallback(resolve)));
+  await dbOK([
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], 4);
 
-    yield cps.removeByDomainAndName("a.com", "bar", null, makeCallback());
-    yield dbOK([
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], 4);
+  await new Promise(resolve => cps.removeGlobal("bar", null, makeCallback(resolve)));
+  await dbOK([
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], undefined);
+  await reset();
+});
 
-    yield cps.removeGlobal("bar", null, makeCallback());
-    yield dbOK([
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], undefined);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["b.a.com", "foo", 2],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["b.a.com", 2]]);
+  await getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    yield cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    yield dbOK([
-      ["b.a.com", "foo", 2],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["b.a.com", 2]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
+  await set("a.com", "foo", 3);
+  await new Promise(resolve => cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], []);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
 
-    yield set("a.com", "foo", 3);
-    yield cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback());
-    yield dbOK([
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], []);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
+  await set("a.com", "foo", 4);
+  await set("b.a.com", "foo", 5);
+  await new Promise(resolve => cps.removeByDomainAndName("b.a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 4],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
+
+  await set("b.a.com", "foo", 6);
+  await new Promise(resolve => cps.removeBySubdomainAndName("b.a.com", "foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 4],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
+  await reset();
+});
 
-    yield set("a.com", "foo", 4);
-    yield set("b.a.com", "foo", 5);
-    yield cps.removeByDomainAndName("b.a.com", "foo", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 4],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await setGlobal("qux", 5);
+  await set("b.com", "foo", 6);
+  await set("b.com", "bar", 7);
 
-    yield set("b.a.com", "foo", 6);
-    yield cps.removeBySubdomainAndName("b.a.com", "foo", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 4],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
-  },
-
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield setGlobal("qux", 5);
-    yield set("b.com", "foo", 6);
-    yield set("b.com", "bar", 7);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 8, context);
+  await setGlobal("foo", 9, context);
+  await new Promise(resolve => cps.removeByDomainAndName("a.com", "foo", context, makeCallback(resolve)));
+  await new Promise(resolve => cps.removeGlobal("foo", context, makeCallback(resolve)));
+  await new Promise(resolve => cps.removeGlobal("qux", context, makeCallback(resolve)));
+  await new Promise(resolve => cps.removeByDomainAndName("b.com", "foo", context, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "bar", 2],
+    [null, "bar", 4],
+    ["b.com", "bar", 7],
+  ]);
+  await getOK(["a.com", "foo", context], undefined);
+  await getOK(["a.com", "bar", context], 2);
+  await getGlobalOK(["foo", context], undefined);
+  await getGlobalOK(["bar", context], 4);
+  await getGlobalOK(["qux", context], undefined);
+  await getOK(["b.com", "foo", context], undefined);
+  await getOK(["b.com", "bar", context], 7);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 8, context);
-    yield setGlobal("foo", 9, context);
-    yield cps.removeByDomainAndName("a.com", "foo", context, makeCallback());
-    yield cps.removeGlobal("foo", context, makeCallback());
-    yield cps.removeGlobal("qux", context, makeCallback());
-    yield cps.removeByDomainAndName("b.com", "foo", context, makeCallback());
-    yield dbOK([
-      ["a.com", "bar", 2],
-      [null, "bar", 4],
-      ["b.com", "bar", 7],
-    ]);
-    yield getOK(["a.com", "foo", context], undefined);
-    yield getOK(["a.com", "bar", context], 2);
-    yield getGlobalOK(["foo", context], undefined);
-    yield getGlobalOK(["bar", context], 4);
-    yield getGlobalOK(["qux", context], undefined);
-    yield getOK(["b.com", "foo", context], undefined);
-    yield getOK(["b.com", "bar", context], 7);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], 4);
+  await getGlobalOK(["qux"], undefined);
+  await getOK(["b.com", "foo"], undefined);
+  await getOK(["b.com", "bar"], 7);
+  await reset();
+});
 
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], 4);
-    yield getGlobalOK(["qux"], undefined);
-    yield getOK(["b.com", "foo"], undefined);
-    yield getOK(["b.com", "bar"], 7);
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.removeByDomainAndName(null, "foo", null));
+  do_check_throws(() => cps.removeByDomainAndName("", "foo", null));
+  do_check_throws(() => cps.removeByDomainAndName("a.com", "foo", null,
+                                                  "bogus"));
+  do_check_throws(() => cps.removeBySubdomainAndName(null, "foo",
+                                                     null));
+  do_check_throws(() => cps.removeBySubdomainAndName("", "foo", null));
+  do_check_throws(() => cps.removeBySubdomainAndName("a.com", "foo",
+                                                     null, "bogus"));
+  do_check_throws(() => cps.removeGlobal("", null));
+  do_check_throws(() => cps.removeGlobal(null, null));
+  do_check_throws(() => cps.removeGlobal("foo", null, "bogus"));
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.removeByDomainAndName(null, "foo", null));
-    do_check_throws(() => cps.removeByDomainAndName("", "foo", null));
-    do_check_throws(() => cps.removeByDomainAndName("a.com", "foo", null,
-                                                    "bogus"));
-    do_check_throws(() => cps.removeBySubdomainAndName(null, "foo",
-                                                       null));
-    do_check_throws(() => cps.removeBySubdomainAndName("", "foo", null));
-    do_check_throws(() => cps.removeBySubdomainAndName("a.com", "foo",
-                                                       null, "bogus"));
-    do_check_throws(() => cps.removeGlobal("", null));
-    do_check_throws(() => cps.removeGlobal(null, null));
-    do_check_throws(() => cps.removeGlobal("foo", null, "bogus"));
-    yield true;
-  },
+add_task(async function removeByDomainAndName_invalidateCache() {
+  await set("a.com", "foo", 1);
+  getCachedOK(["a.com", "foo"], true, 1);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeByDomainAndName("a.com", "foo", null, makeCallback(resolve));
+  });
+  getCachedOK(["a.com", "foo"], false);
+  await promiseRemoved;
+  await reset();
+});
 
-  function* removeByDomainAndName_invalidateCache() {
-    yield set("a.com", "foo", 1);
-    getCachedOK(["a.com", "foo"], true, 1);
-    cps.removeByDomainAndName("a.com", "foo", null, makeCallback());
-    getCachedOK(["a.com", "foo"], false);
-    yield;
-  },
+add_task(async function removeBySubdomainAndName_invalidateCache() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  getCachedSubdomainsOK(["a.com", "foo"], [
+    ["a.com", 1],
+    ["b.a.com", 2],
+  ]);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback(resolve));
+  });
+  getCachedSubdomainsOK(["a.com", "foo"], []);
+  await promiseRemoved;
+  await reset();
+});
 
-  function* removeBySubdomainAndName_invalidateCache() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    getCachedSubdomainsOK(["a.com", "foo"], [
-      ["a.com", 1],
-      ["b.a.com", 2],
-    ]);
-    cps.removeBySubdomainAndName("a.com", "foo", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], []);
-    yield;
-  },
-
-  function* removeGlobal_invalidateCache() {
-    yield setGlobal("foo", 1);
-    getCachedGlobalOK(["foo"], true, 1);
-    cps.removeGlobal("foo", null, makeCallback());
-    getCachedGlobalOK(["foo"], false);
-    yield;
-  },
-];
+add_task(async function removeGlobal_invalidateCache() {
+  await setGlobal("foo", 1);
+  getCachedGlobalOK(["foo"], true, 1);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeGlobal("foo", null, makeCallback(resolve));
+  });
+  getCachedGlobalOK(["foo"], false);
+  await promiseRemoved;
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomains.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomains.js
@@ -1,87 +1,88 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
-
-var tests = [
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-  function* nonexistent() {
-    yield setGlobal("foo", 1);
-    yield cps.removeAllDomains(null, makeCallback());
-    yield dbOK([
-      [null, "foo", 1],
-    ]);
-    yield getGlobalOK(["foo"], 1);
-  },
+add_task(async function nonexistent() {
+  await setGlobal("foo", 1);
+  await new Promise(resolve => cps.removeAllDomains(null, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 1],
+  ]);
+  await getGlobalOK(["foo"], 1);
+  await reset();
+});
 
-  function* domains() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
-    yield set("b.com", "bar", 6);
+add_task(async function domains() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+  await set("b.com", "bar", 6);
 
-    yield cps.removeAllDomains(null, makeCallback());
-    yield dbOK([
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], undefined);
-    yield getOK(["b.com", "bar"], undefined);
-  },
+  await new Promise(resolve => cps.removeAllDomains(null, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], undefined);
+  await getOK(["b.com", "bar"], undefined);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    yield cps.removeAllDomains(context, makeCallback());
-    yield dbOK([
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo", context], undefined);
-    yield getOK(["a.com", "bar", context], undefined);
-    yield getGlobalOK(["foo", context], 7);
-    yield getGlobalOK(["bar", context], 4);
-    yield getOK(["b.com", "foo", context], undefined);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  await new Promise(resolve => cps.removeAllDomains(context, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo", context], undefined);
+  await getOK(["a.com", "bar", context], undefined);
+  await getGlobalOK(["foo", context], 7);
+  await getGlobalOK(["bar", context], 4);
+  await getOK(["b.com", "foo", context], undefined);
 
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], undefined);
-  },
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], undefined);
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.removeAllDomains(null, "bogus"));
-    yield true;
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.removeAllDomains(null, "bogus"));
+  await reset();
+});
 
-  function* invalidateCache() {
-    yield set("a.com", "foo", 1);
-    yield set("b.com", "bar", 2);
-    yield setGlobal("baz", 3);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["b.com", "bar"], true, 2);
-    getCachedGlobalOK(["baz"], true, 3);
-    cps.removeAllDomains(null, makeCallback());
-    getCachedOK(["a.com", "foo"], false);
-    getCachedOK(["b.com", "bar"], false);
-    getCachedGlobalOK(["baz"], true, 3);
-    yield;
-  },
-];
+add_task(async function invalidateCache() {
+  await set("a.com", "foo", 1);
+  await set("b.com", "bar", 2);
+  await setGlobal("baz", 3);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["b.com", "bar"], true, 2);
+  getCachedGlobalOK(["baz"], true, 3);
+  let promiseRemoved = new Promise(resolve => cps.removeAllDomains(null, makeCallback(resolve)));
+  getCachedOK(["a.com", "foo"], false);
+  getCachedOK(["b.com", "bar"], false);
+  getCachedGlobalOK(["baz"], true, 3);
+  await promiseRemoved;
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomainsSince.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_removeAllDomainsSince.js
@@ -1,111 +1,115 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
-
-var tests = [
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-  function* nonexistent() {
-    yield setGlobal("foo", 1);
-    yield cps.removeAllDomainsSince(0, null, makeCallback());
-    yield getGlobalOK(["foo"], 1);
-  },
+add_task(async function nonexistent() {
+  await setGlobal("foo", 1);
+  await new Promise(resolve => cps.removeAllDomainsSince(0, null, makeCallback(resolve)));
+  await getGlobalOK(["foo"], 1);
+  await reset();
+});
 
-  function* domainsAll() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
-    yield set("b.com", "bar", 6);
+add_task(async function domainsAll() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+  await set("b.com", "bar", 6);
 
-    yield cps.removeAllDomainsSince(0, null, makeCallback());
-    yield dbOK([
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], undefined);
-    yield getOK(["b.com", "bar"], undefined);
-  },
+  await new Promise(resolve => cps.removeAllDomainsSince(0, null, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], undefined);
+  await getOK(["b.com", "bar"], undefined);
+  await reset();
+});
 
-  function* domainsWithDate() {
-    yield setWithDate("a.com", "foobar", 0, 0);
-    yield setWithDate("a.com", "foo", 1, 1000);
-    yield setWithDate("a.com", "bar", 2, 4000);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield setWithDate("b.com", "foo", 5, 2000);
-    yield setWithDate("b.com", "bar", 6, 3000);
-    yield setWithDate("b.com", "foobar", 7, 1000);
+add_task(async function domainsWithDate() {
+  await setWithDate("a.com", "foobar", 0, 0);
+  await setWithDate("a.com", "foo", 1, 1000);
+  await setWithDate("a.com", "bar", 2, 4000);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await setWithDate("b.com", "foo", 5, 2000);
+  await setWithDate("b.com", "bar", 6, 3000);
+  await setWithDate("b.com", "foobar", 7, 1000);
 
-    yield cps.removeAllDomainsSince(2000, null, makeCallback());
-    yield dbOK([
-      ["a.com", "foobar", 0],
-      ["a.com", "foo", 1],
-      [null, "foo", 3],
-      [null, "bar", 4],
-      ["b.com", "foobar", 7],
-    ]);
-  },
+  await new Promise(resolve => cps.removeAllDomainsSince(2000, null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foobar", 0],
+    ["a.com", "foo", 1],
+    [null, "foo", 3],
+    [null, "bar", 4],
+    ["b.com", "foobar", 7],
+  ]);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    yield cps.removeAllDomainsSince(0, context, makeCallback());
-    yield dbOK([
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo", context], undefined);
-    yield getOK(["a.com", "bar", context], undefined);
-    yield getGlobalOK(["foo", context], 7);
-    yield getGlobalOK(["bar", context], 4);
-    yield getOK(["b.com", "foo", context], undefined);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  await new Promise(resolve => cps.removeAllDomainsSince(0, context, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo", context], undefined);
+  await getOK(["a.com", "bar", context], undefined);
+  await getGlobalOK(["foo", context], 7);
+  await getGlobalOK(["bar", context], 4);
+  await getOK(["b.com", "foo", context], undefined);
+
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], undefined);
+  await reset();
+});
 
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], undefined);
-  },
-
-  function* erroneous() {
-    do_check_throws(() => cps.removeAllDomainsSince(null, "bogus"));
-    yield true;
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.removeAllDomainsSince(null, "bogus"));
+  await reset();
+});
 
-  function* invalidateCache() {
-    yield setWithDate("a.com", "foobar", 0, 0);
-    yield setWithDate("a.com", "foo", 1, 1000);
-    yield setWithDate("a.com", "bar", 2, 4000);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield setWithDate("b.com", "foo", 5, 2000);
-    yield setWithDate("b.com", "bar", 6, 3000);
-    yield setWithDate("b.com", "foobar", 7, 1000);
-    cps.removeAllDomainsSince(0, null, makeCallback());
-    getCachedOK(["a.com", "foobar"], false);
-    getCachedOK(["a.com", "foo"], false);
-    getCachedOK(["a.com", "bar"], false);
-    getCachedGlobalOK(["foo"], true, 3);
-    getCachedGlobalOK(["bar"], true, 4);
-    getCachedOK(["b.com", "foo"], false);
-    getCachedOK(["b.com", "bar"], false);
-    getCachedOK(["b.com", "foobar"], false);
-    yield true;
-  },
-];
+add_task(async function invalidateCache() {
+  await setWithDate("a.com", "foobar", 0, 0);
+  await setWithDate("a.com", "foo", 1, 1000);
+  await setWithDate("a.com", "bar", 2, 4000);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await setWithDate("b.com", "foo", 5, 2000);
+  await setWithDate("b.com", "bar", 6, 3000);
+  await setWithDate("b.com", "foobar", 7, 1000);
+  let clearPromise = new Promise(resolve => {
+    cps.removeAllDomainsSince(0, null, makeCallback(resolve));
+  });
+  getCachedOK(["a.com", "foobar"], false);
+  getCachedOK(["a.com", "foo"], false);
+  getCachedOK(["a.com", "bar"], false);
+  getCachedGlobalOK(["foo"], true, 3);
+  getCachedGlobalOK(["bar"], true, 4);
+  getCachedOK(["b.com", "foo"], false);
+  getCachedOK(["b.com", "bar"], false);
+  getCachedOK(["b.com", "foobar"], false);
+  await clearPromise;
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_removeByDomain.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_removeByDomain.js
@@ -1,199 +1,210 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-var tests = [
+add_task(async function nonexistent() {
+  await set("a.com", "foo", 1);
+  await setGlobal("foo", 2);
 
-  function* nonexistent() {
-    yield set("a.com", "foo", 1);
-    yield setGlobal("foo", 2);
-
-    yield cps.removeByDomain("bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
+  await new Promise(resolve => cps.removeByDomain("bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
 
-    yield cps.removeBySubdomain("bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
-  },
+  await new Promise(resolve => cps.removeBySubdomain("bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
+  await reset();
+});
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    yield cps.removeByDomain("a.com", null, makeCallback());
-    yield dbOK([]);
-    yield getOK(["a.com", "foo"], undefined);
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  await new Promise(resolve => cps.removeByDomain("a.com", null, makeCallback(resolve)));
+  await dbOK([]);
+  await getOK(["a.com", "foo"], undefined);
 
-    yield set("a.com", "foo", 2);
-    yield cps.removeByDomain("http://a.com/huh", null, makeCallback());
-    yield dbOK([]);
-    yield getOK(["a.com", "foo"], undefined);
-  },
+  await set("a.com", "foo", 2);
+  await new Promise(resolve => cps.removeByDomain("http://a.com/huh", null, makeCallback(resolve)));
+  await dbOK([]);
+  await getOK(["a.com", "foo"], undefined);
+  await reset();
+});
 
-  function* domains() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
-    yield set("b.com", "bar", 6);
+add_task(async function domains() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+  await set("b.com", "bar", 6);
 
-    yield cps.removeByDomain("a.com", null, makeCallback());
-    yield dbOK([
-      [null, "foo", 3],
-      [null, "bar", 4],
-      ["b.com", "foo", 5],
-      ["b.com", "bar", 6],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], 5);
-    yield getOK(["b.com", "bar"], 6);
+  await new Promise(resolve => cps.removeByDomain("a.com", null, makeCallback(resolve)));
+  await dbOK([
+    [null, "foo", 3],
+    [null, "bar", 4],
+    ["b.com", "foo", 5],
+    ["b.com", "bar", 6],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], 5);
+  await getOK(["b.com", "bar"], 6);
+
+  await new Promise(resolve => cps.removeAllGlobals(null, makeCallback(resolve)));
+  await dbOK([
+    ["b.com", "foo", 5],
+    ["b.com", "bar", 6],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], undefined);
+  await getOK(["b.com", "foo"], 5);
+  await getOK(["b.com", "bar"], 6);
 
-    yield cps.removeAllGlobals(null, makeCallback());
-    yield dbOK([
-      ["b.com", "foo", 5],
-      ["b.com", "bar", 6],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], undefined);
-    yield getOK(["b.com", "foo"], 5);
-    yield getOK(["b.com", "bar"], 6);
+  await new Promise(resolve => cps.removeByDomain("b.com", null, makeCallback(resolve)));
+  await dbOK([
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], undefined);
+  await getOK(["b.com", "foo"], undefined);
+  await getOK(["b.com", "bar"], undefined);
+  await reset();
+});
 
-    yield cps.removeByDomain("b.com", null, makeCallback());
-    yield dbOK([
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], undefined);
-    yield getOK(["b.com", "foo"], undefined);
-    yield getOK(["b.com", "bar"], undefined);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  await new Promise(resolve => cps.removeByDomain("a.com", null, makeCallback(resolve)));
+  await dbOK([
+    ["b.a.com", "foo", 2],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["b.a.com", 2]]);
+  await getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    yield cps.removeByDomain("a.com", null, makeCallback());
-    yield dbOK([
-      ["b.a.com", "foo", 2],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["b.a.com", 2]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], [["b.a.com", 2]]);
+  await set("a.com", "foo", 3);
+  await new Promise(resolve => cps.removeBySubdomain("a.com", null, makeCallback(resolve)));
+  await dbOK([
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], []);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
 
-    yield set("a.com", "foo", 3);
-    yield cps.removeBySubdomain("a.com", null, makeCallback());
-    yield dbOK([
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], []);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
+  await set("a.com", "foo", 4);
+  await set("b.a.com", "foo", 5);
+  await new Promise(resolve => cps.removeByDomain("b.a.com", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 4],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
 
-    yield set("a.com", "foo", 4);
-    yield set("b.a.com", "foo", 5);
-    yield cps.removeByDomain("b.a.com", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 4],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
+  await set("b.a.com", "foo", 6);
+  await new Promise(resolve => cps.removeBySubdomain("b.a.com", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 4],
+  ]);
+  await getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
+  await getSubdomainsOK(["b.a.com", "foo"], []);
+  await reset();
+});
 
-    yield set("b.a.com", "foo", 6);
-    yield cps.removeBySubdomain("b.a.com", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 4],
-    ]);
-    yield getSubdomainsOK(["a.com", "foo"], [["a.com", 4]]);
-    yield getSubdomainsOK(["b.a.com", "foo"], []);
-  },
-
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield set("b.com", "foo", 7, context);
-    yield setGlobal("foo", 8, context);
-    yield cps.removeByDomain("a.com", context, makeCallback());
-    yield getOK(["b.com", "foo", context], 7);
-    yield getGlobalOK(["foo", context], 8);
-    yield cps.removeAllGlobals(context, makeCallback());
-    yield dbOK([
-      ["b.com", "foo", 5],
-    ]);
-    yield getOK(["a.com", "foo", context], undefined);
-    yield getOK(["a.com", "bar", context], undefined);
-    yield getGlobalOK(["foo", context], undefined);
-    yield getGlobalOK(["bar", context], undefined);
-    yield getOK(["b.com", "foo", context], 5);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await set("b.com", "foo", 7, context);
+  await setGlobal("foo", 8, context);
+  await new Promise(resolve => cps.removeByDomain("a.com", context, makeCallback(resolve)));
+  await getOK(["b.com", "foo", context], 7);
+  await getGlobalOK(["foo", context], 8);
+  await new Promise(resolve => cps.removeAllGlobals(context, makeCallback(resolve)));
+  await dbOK([
+    ["b.com", "foo", 5],
+  ]);
+  await getOK(["a.com", "foo", context], undefined);
+  await getOK(["a.com", "bar", context], undefined);
+  await getGlobalOK(["foo", context], undefined);
+  await getGlobalOK(["bar", context], undefined);
+  await getOK(["b.com", "foo", context], 5);
+
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], undefined);
+  await getOK(["b.com", "foo"], 5);
+  await reset();
+});
 
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], undefined);
-    yield getOK(["b.com", "foo"], 5);
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.removeByDomain(null, null));
+  do_check_throws(() => cps.removeByDomain("", null));
+  do_check_throws(() => cps.removeByDomain("a.com", null, "bogus"));
+  do_check_throws(() => cps.removeBySubdomain(null, null));
+  do_check_throws(() => cps.removeBySubdomain("", null));
+  do_check_throws(() => cps.removeBySubdomain("a.com", null, "bogus"));
+  do_check_throws(() => cps.removeAllGlobals(null, "bogus"));
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.removeByDomain(null, null));
-    do_check_throws(() => cps.removeByDomain("", null));
-    do_check_throws(() => cps.removeByDomain("a.com", null, "bogus"));
-    do_check_throws(() => cps.removeBySubdomain(null, null));
-    do_check_throws(() => cps.removeBySubdomain("", null));
-    do_check_throws(() => cps.removeBySubdomain("a.com", null, "bogus"));
-    do_check_throws(() => cps.removeAllGlobals(null, "bogus"));
-    yield true;
-  },
+add_task(async function removeByDomain_invalidateCache() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["a.com", "bar"], true, 2);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeByDomain("a.com", null, makeCallback(resolve));
+  });
+  getCachedOK(["a.com", "foo"], false);
+  getCachedOK(["a.com", "bar"], false);
+  await promiseRemoved;
+  await reset();
+});
 
-  function* removeByDomain_invalidateCache() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["a.com", "bar"], true, 2);
-    cps.removeByDomain("a.com", null, makeCallback());
-    getCachedOK(["a.com", "foo"], false);
-    getCachedOK(["a.com", "bar"], false);
-    yield;
-  },
+add_task(async function removeBySubdomain_invalidateCache() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  getCachedSubdomainsOK(["a.com", "foo"], [
+    ["a.com", 1],
+    ["b.a.com", 2],
+  ]);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeBySubdomain("a.com", null, makeCallback(resolve));
+  });
+  getCachedSubdomainsOK(["a.com", "foo"], []);
+  await promiseRemoved;
+  await reset();
+});
 
-  function* removeBySubdomain_invalidateCache() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    getCachedSubdomainsOK(["a.com", "foo"], [
-      ["a.com", 1],
-      ["b.a.com", 2],
-    ]);
-    cps.removeBySubdomain("a.com", null, makeCallback());
-    getCachedSubdomainsOK(["a.com", "foo"], []);
-    yield;
-  },
-
-  function* removeAllGlobals_invalidateCache() {
-    yield setGlobal("foo", 1);
-    yield setGlobal("bar", 2);
-    getCachedGlobalOK(["foo"], true, 1);
-    getCachedGlobalOK(["bar"], true, 2);
-    cps.removeAllGlobals(null, makeCallback());
-    getCachedGlobalOK(["foo"], false);
-    getCachedGlobalOK(["bar"], false);
-    yield;
-  },
-];
+add_task(async function removeAllGlobals_invalidateCache() {
+  await setGlobal("foo", 1);
+  await setGlobal("bar", 2);
+  getCachedGlobalOK(["foo"], true, 1);
+  getCachedGlobalOK(["bar"], true, 2);
+  let promiseRemoved = new Promise(resolve => {
+    cps.removeAllGlobals(null, makeCallback(resolve));
+  });
+  getCachedGlobalOK(["foo"], false);
+  getCachedGlobalOK(["bar"], false);
+  await promiseRemoved;
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_removeByName.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_removeByName.js
@@ -1,96 +1,96 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-var tests = [
+add_task(async function nonexistent() {
+  await set("a.com", "foo", 1);
+  await setGlobal("foo", 2);
 
-  function* nonexistent() {
-    yield set("a.com", "foo", 1);
-    yield setGlobal("foo", 2);
-
-    yield cps.removeByName("bogus", null, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getGlobalOK(["foo"], 2);
-  },
+  await new Promise(resolve => cps.removeByName("bogus", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getGlobalOK(["foo"], 2);
+  await reset();
+});
 
-  function* names() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
-    yield set("b.com", "bar", 6);
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+  await set("b.com", "bar", 6);
 
-    yield cps.removeByName("foo", null, makeCallback());
-    yield dbOK([
-      ["a.com", "bar", 2],
-      [null, "bar", 4],
-      ["b.com", "bar", 6],
-    ]);
-    yield getOK(["a.com", "foo"], undefined);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], undefined);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], undefined);
-    yield getOK(["b.com", "bar"], 6);
-  },
+  await new Promise(resolve => cps.removeByName("foo", null, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "bar", 2],
+    [null, "bar", 4],
+    ["b.com", "bar", 6],
+  ]);
+  await getOK(["a.com", "foo"], undefined);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], undefined);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], undefined);
+  await getOK(["b.com", "bar"], 6);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
-    yield set("b.com", "bar", 6);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
+  await set("b.com", "bar", 6);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 7, context);
-    yield setGlobal("foo", 8, context);
-    yield set("b.com", "bar", 9, context);
-    yield cps.removeByName("bar", context, makeCallback());
-    yield dbOK([
-      ["a.com", "foo", 1],
-      [null, "foo", 3],
-      ["b.com", "foo", 5],
-    ]);
-    yield getOK(["a.com", "foo", context], 7);
-    yield getOK(["a.com", "bar", context], undefined);
-    yield getGlobalOK(["foo", context], 8);
-    yield getGlobalOK(["bar", context], undefined);
-    yield getOK(["b.com", "foo", context], 5);
-    yield getOK(["b.com", "bar", context], undefined);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 7, context);
+  await setGlobal("foo", 8, context);
+  await set("b.com", "bar", 9, context);
+  await new Promise(resolve => cps.removeByName("bar", context, makeCallback(resolve)));
+  await dbOK([
+    ["a.com", "foo", 1],
+    [null, "foo", 3],
+    ["b.com", "foo", 5],
+  ]);
+  await getOK(["a.com", "foo", context], 7);
+  await getOK(["a.com", "bar", context], undefined);
+  await getGlobalOK(["foo", context], 8);
+  await getGlobalOK(["bar", context], undefined);
+  await getOK(["b.com", "foo", context], 5);
+  await getOK(["b.com", "bar", context], undefined);
 
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["a.com", "bar"], undefined);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], undefined);
-    yield getOK(["b.com", "foo"], 5);
-    yield getOK(["b.com", "bar"], undefined);
-  },
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["a.com", "bar"], undefined);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], undefined);
+  await getOK(["b.com", "foo"], 5);
+  await getOK(["b.com", "bar"], undefined);
+  await reset();
+});
 
-  function* erroneous() {
-    do_check_throws(() => cps.removeByName("", null));
-    do_check_throws(() => cps.removeByName(null, null));
-    do_check_throws(() => cps.removeByName("foo", null, "bogus"));
-    yield true;
-  },
+add_task(async function erroneous() {
+  do_check_throws(() => cps.removeByName("", null));
+  do_check_throws(() => cps.removeByName(null, null));
+  do_check_throws(() => cps.removeByName("foo", null, "bogus"));
+  await reset();
+});
 
-  function* invalidateCache() {
-    yield set("a.com", "foo", 1);
-    yield set("b.com", "foo", 2);
-    getCachedOK(["a.com", "foo"], true, 1);
-    getCachedOK(["b.com", "foo"], true, 2);
-    cps.removeByName("foo", null, makeCallback());
-    getCachedOK(["a.com", "foo"], false);
-    getCachedOK(["b.com", "foo"], false);
-    yield;
-  },
-];
+add_task(async function invalidateCache() {
+  await set("a.com", "foo", 1);
+  await set("b.com", "foo", 2);
+  getCachedOK(["a.com", "foo"], true, 1);
+  getCachedOK(["b.com", "foo"], true, 2);
+  cps.removeByName("foo", null, makeCallback());
+  getCachedOK(["a.com", "foo"], false);
+  getCachedOK(["b.com", "foo"], false);
+  await reset();
+});
--- a/toolkit/components/contentprefs/tests/unit_cps2/test_setGet.js
+++ b/toolkit/components/contentprefs/tests/unit_cps2/test_setGet.js
@@ -1,206 +1,211 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-function run_test() {
-  runAsyncTests(tests);
-}
-
-var tests = [
+add_task(async function resetBeforeTests() {
+  await reset();
+});
 
-  function* get_nonexistent() {
-    yield getOK(["a.com", "foo"], undefined);
-    yield getGlobalOK(["foo"], undefined);
-  },
+add_task(async function get_nonexistent() {
+  await getOK(["a.com", "foo"], undefined);
+  await getGlobalOK(["foo"], undefined);
+  await reset();
+});
 
-  function* isomorphicDomains() {
-    yield set("a.com", "foo", 1);
-    yield dbOK([
-      ["a.com", "foo", 1],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["http://a.com/huh", "foo"], 1, "a.com");
+add_task(async function isomorphicDomains() {
+  await set("a.com", "foo", 1);
+  await dbOK([
+    ["a.com", "foo", 1],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["http://a.com/huh", "foo"], 1, "a.com");
 
-    yield set("http://a.com/huh", "foo", 2);
-    yield dbOK([
-      ["a.com", "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 2);
-    yield getOK(["http://a.com/yeah", "foo"], 2, "a.com");
-  },
+  await set("http://a.com/huh", "foo", 2);
+  await dbOK([
+    ["a.com", "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 2);
+  await getOK(["http://a.com/yeah", "foo"], 2, "a.com");
+  await reset();
+});
 
-  function* names() {
-    yield set("a.com", "foo", 1);
-    yield dbOK([
-      ["a.com", "foo", 1],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
+add_task(async function names() {
+  await set("a.com", "foo", 1);
+  await dbOK([
+    ["a.com", "foo", 1],
+  ]);
+  await getOK(["a.com", "foo"], 1);
 
-    yield set("a.com", "bar", 2);
-    yield dbOK([
-      ["a.com", "foo", 1],
-      ["a.com", "bar", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["a.com", "bar"], 2);
+  await set("a.com", "bar", 2);
+  await dbOK([
+    ["a.com", "foo", 1],
+    ["a.com", "bar", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["a.com", "bar"], 2);
 
-    yield setGlobal("foo", 3);
-    yield dbOK([
-      ["a.com", "foo", 1],
-      ["a.com", "bar", 2],
-      [null, "foo", 3],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], 3);
+  await setGlobal("foo", 3);
+  await dbOK([
+    ["a.com", "foo", 1],
+    ["a.com", "bar", 2],
+    [null, "foo", 3],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], 3);
 
-    yield setGlobal("bar", 4);
-    yield dbOK([
-      ["a.com", "foo", 1],
-      ["a.com", "bar", 2],
-      [null, "foo", 3],
-      [null, "bar", 4],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-  },
+  await setGlobal("bar", 4);
+  await dbOK([
+    ["a.com", "foo", 1],
+    ["a.com", "bar", 2],
+    [null, "foo", 3],
+    [null, "bar", 4],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await reset();
+});
 
-  function* subdomains() {
-    yield set("a.com", "foo", 1);
-    yield set("b.a.com", "foo", 2);
-    yield dbOK([
-      ["a.com", "foo", 1],
-      ["b.a.com", "foo", 2],
-    ]);
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["b.a.com", "foo"], 2);
-  },
+add_task(async function subdomains() {
+  await set("a.com", "foo", 1);
+  await set("b.a.com", "foo", 2);
+  await dbOK([
+    ["a.com", "foo", 1],
+    ["b.a.com", "foo", 2],
+  ]);
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["b.a.com", "foo"], 2);
+  await reset();
+});
 
-  function* privateBrowsing() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield setGlobal("foo", 3);
-    yield setGlobal("bar", 4);
-    yield set("b.com", "foo", 5);
+add_task(async function privateBrowsing() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await setGlobal("foo", 3);
+  await setGlobal("bar", 4);
+  await set("b.com", "foo", 5);
 
-    let context = privateLoadContext;
-    yield set("a.com", "foo", 6, context);
-    yield setGlobal("foo", 7, context);
-    yield dbOK([
-      ["a.com", "foo", 1],
-      ["a.com", "bar", 2],
-      [null, "foo", 3],
-      [null, "bar", 4],
-      ["b.com", "foo", 5],
-    ]);
-    yield getOK(["a.com", "foo", context], 6, "a.com");
-    yield getOK(["a.com", "bar", context], 2);
-    yield getGlobalOK(["foo", context], 7);
-    yield getGlobalOK(["bar", context], 4);
-    yield getOK(["b.com", "foo", context], 5);
+  let context = privateLoadContext;
+  await set("a.com", "foo", 6, context);
+  await setGlobal("foo", 7, context);
+  await dbOK([
+    ["a.com", "foo", 1],
+    ["a.com", "bar", 2],
+    [null, "foo", 3],
+    [null, "bar", 4],
+    ["b.com", "foo", 5],
+  ]);
+  await getOK(["a.com", "foo", context], 6, "a.com");
+  await getOK(["a.com", "bar", context], 2);
+  await getGlobalOK(["foo", context], 7);
+  await getGlobalOK(["bar", context], 4);
+  await getOK(["b.com", "foo", context], 5);
 
-    yield getOK(["a.com", "foo"], 1);
-    yield getOK(["a.com", "bar"], 2);
-    yield getGlobalOK(["foo"], 3);
-    yield getGlobalOK(["bar"], 4);
-    yield getOK(["b.com", "foo"], 5);
-  },
+  await getOK(["a.com", "foo"], 1);
+  await getOK(["a.com", "bar"], 2);
+  await getGlobalOK(["foo"], 3);
+  await getGlobalOK(["bar"], 4);
+  await getOK(["b.com", "foo"], 5);
+  await reset();
+});
 
-  function* set_erroneous() {
-    do_check_throws(() => cps.set(null, "foo", 1, null));
-    do_check_throws(() => cps.set("", "foo", 1, null));
-    do_check_throws(() => cps.set("a.com", "", 1, null));
-    do_check_throws(() => cps.set("a.com", null, 1, null));
-    do_check_throws(() => cps.set("a.com", "foo", undefined, null));
-    do_check_throws(() => cps.set("a.com", "foo", 1, null, "bogus"));
-    do_check_throws(() => cps.setGlobal("", 1, null));
-    do_check_throws(() => cps.setGlobal(null, 1, null));
-    do_check_throws(() => cps.setGlobal("foo", undefined, null));
-    do_check_throws(() => cps.setGlobal("foo", 1, null, "bogus"));
-    yield true;
-  },
+add_task(async function set_erroneous() {
+  do_check_throws(() => cps.set(null, "foo", 1, null));
+  do_check_throws(() => cps.set("", "foo", 1, null));
+  do_check_throws(() => cps.set("a.com", "", 1, null));
+  do_check_throws(() => cps.set("a.com", null, 1, null));
+  do_check_throws(() => cps.set("a.com", "foo", undefined, null));
+  do_check_throws(() => cps.set("a.com", "foo", 1, null, "bogus"));
+  do_check_throws(() => cps.setGlobal("", 1, null));
+  do_check_throws(() => cps.setGlobal(null, 1, null));
+  do_check_throws(() => cps.setGlobal("foo", undefined, null));
+  do_check_throws(() => cps.setGlobal("foo", 1, null, "bogus"));
+  await reset();
+});
 
-  function* get_erroneous() {
-    do_check_throws(() => cps.getByDomainAndName(null, "foo", null, {}));
-    do_check_throws(() => cps.getByDomainAndName("", "foo", null, {}));
-    do_check_throws(() => cps.getByDomainAndName("a.com", "", null, {}));
-    do_check_throws(() => cps.getByDomainAndName("a.com", null, null, {}));
-    do_check_throws(() => cps.getByDomainAndName("a.com", "foo", null, null));
-    do_check_throws(() => cps.getGlobal("", null, {}));
-    do_check_throws(() => cps.getGlobal(null, null, {}));
-    do_check_throws(() => cps.getGlobal("foo", null, null));
-    yield true;
-  },
+add_task(async function get_erroneous() {
+  do_check_throws(() => cps.getByDomainAndName(null, "foo", null, {}));
+  do_check_throws(() => cps.getByDomainAndName("", "foo", null, {}));
+  do_check_throws(() => cps.getByDomainAndName("a.com", "", null, {}));
+  do_check_throws(() => cps.getByDomainAndName("a.com", null, null, {}));
+  do_check_throws(() => cps.getByDomainAndName("a.com", "foo", null, null));
+  do_check_throws(() => cps.getGlobal("", null, {}));
+  do_check_throws(() => cps.getGlobal(null, null, {}));
+  do_check_throws(() => cps.getGlobal("foo", null, null));
+  await reset();
+});
 
-  function* set_invalidateCache() {
-    // (1) Set a pref and wait for it to finish.
-    yield set("a.com", "foo", 1);
+add_task(async function set_invalidateCache() {
+  // (1) Set a pref and wait for it to finish.
+  await set("a.com", "foo", 1);
 
-    // (2) It should be cached.
-    getCachedOK(["a.com", "foo"], true, 1);
+  // (2) It should be cached.
+  getCachedOK(["a.com", "foo"], true, 1);
 
-    // (3) Set the pref to a new value but don't wait for it to finish.
-    cps.set("a.com", "foo", 2, null, {
-      handleCompletion() {
-        // (6) The pref should be cached after setting it.
-        getCachedOK(["a.com", "foo"], true, 2);
-      },
-    });
+  // (3) Set the pref to a new value but don't wait for it to finish.
+  cps.set("a.com", "foo", 2, null, {
+    handleCompletion() {
+      // (6) The pref should be cached after setting it.
+      getCachedOK(["a.com", "foo"], true, 2);
+    },
+  });
 
-    // (4) Group "a.com" and name "foo" should no longer be cached.
-    getCachedOK(["a.com", "foo"], false);
+  // (4) Group "a.com" and name "foo" should no longer be cached.
+  getCachedOK(["a.com", "foo"], false);
 
-    // (5) Call getByDomainAndName.
-    var fetchedPref;
-    cps.getByDomainAndName("a.com", "foo", null, {
-      handleResult(pref) {
-        fetchedPref = pref;
-      },
-      handleCompletion() {
-        // (7) Finally, this callback should be called after set's above.
-        Assert.ok(!!fetchedPref);
-        Assert.equal(fetchedPref.value, 2);
-        next();
-      },
-    });
+  // (5) Call getByDomainAndName.
+  let fetchedPref;
+  let getPromise = new Promise(resolve => cps.getByDomainAndName("a.com", "foo", null, {
+    handleResult(pref) {
+      fetchedPref = pref;
+    },
+    handleCompletion() {
+      // (7) Finally, this callback should be called after set's above.
+      Assert.ok(!!fetchedPref);
+      Assert.equal(fetchedPref.value, 2);
+      resolve();
+    },
+  }));
 
-    yield;
-  },
+  await getPromise;
+  await reset();
+});
 
-  function* get_nameOnly() {
-    yield set("a.com", "foo", 1);
-    yield set("a.com", "bar", 2);
-    yield set("b.com", "foo", 3);
-    yield setGlobal("foo", 4);
+add_task(async function get_nameOnly() {
+  await set("a.com", "foo", 1);
+  await set("a.com", "bar", 2);
+  await set("b.com", "foo", 3);
+  await setGlobal("foo", 4);
 
-    yield getOKEx("getByName", ["foo", undefined], [
-      {"domain": "a.com", "name": "foo", "value": 1},
-      {"domain": "b.com", "name": "foo", "value": 3},
-      {"domain": null, "name": "foo", "value": 4}
-    ]);
+  await getOKEx("getByName", ["foo", undefined], [
+    {"domain": "a.com", "name": "foo", "value": 1},
+    {"domain": "b.com", "name": "foo", "value": 3},
+    {"domain": null, "name": "foo", "value": 4}
+  ]);
 
-    let context = privateLoadContext;
-    yield set("b.com", "foo", 5, context);
+  let context = privateLoadContext;
+  await set("b.com", "foo", 5, context);
 
-    yield getOKEx("getByName", ["foo", context], [
-      {"domain": "a.com", "name": "foo", "value": 1},
-      {"domain": null, "name": "foo", "value": 4},
-      {"domain": "b.com", "name": "foo", "value": 5}
-    ]);
-  },
+  await getOKEx("getByName", ["foo", context], [
+    {"domain": "a.com", "name": "foo", "value": 1},
+    {"domain": null, "name": "foo", "value": 4},
+    {"domain": "b.com", "name": "foo", "value": 5}
+  ]);
+  await reset();
+});
 
-  function* setSetsCurrentDate() {
-    // Because Date.now() is not guaranteed to be monotonically increasing
-    // we just do here rough sanity check with one minute tolerance.
-    const MINUTE = 60 * 1000;
-    let now = Date.now();
-    let start = now - MINUTE;
-    let end = now + MINUTE;
-    yield set("a.com", "foo", 1);
-    let timestamp = yield getDate("a.com", "foo");
-    ok(start <= timestamp, "Timestamp is not too early (" + start + "<=" + timestamp + ").");
-    ok(timestamp <= end, "Timestamp is not too late (" + timestamp + "<=" + end + ").");
-  },
-];
+add_task(async function setSetsCurrentDate() {
+  // Because Date.now() is not guaranteed to be monotonically increasing
+  // we just do here rough sanity check with one minute tolerance.
+  const MINUTE = 60 * 1000;
+  let now = Date.now();
+  let start = now - MINUTE;
+  let end = now + MINUTE;
+  await set("a.com", "foo", 1);
+  let timestamp = await getDate("a.com", "foo");
+  ok(start <= timestamp, "Timestamp is not too early (" + start + "<=" + timestamp + ").");
+  ok(timestamp <= end, "Timestamp is not too late (" + timestamp + "<=" + end + ").");
+  await reset();
+});