--- a/services/sync/modules-testing/utils.js
+++ b/services/sync/modules-testing/utils.js
@@ -11,17 +11,18 @@ this.EXPORTED_SYMBOLS = [
   "ensureLegacyIdentityManager",
   "setBasicCredentials",
   "makeIdentityConfig",
   "makeFxAccountsInternalMock",
   "configureFxAccountIdentity",
   "configureIdentity",
   "SyncTestingInfrastructure",
   "waitForZeroTimer",
-  "Promise", // from a module import
+  "promiseZeroTimer",
+  "promiseNamedTimer",
   "add_identity_test",
   "MockFxaStorageManager",
   "AccountState", // from a module import
   "sumHistogram",
 ];
 
 var {utils: Cu} = Components;
 
@@ -31,17 +32,16 @@ Cu.import("resource://services-common/ut
 Cu.import("resource://services-crypto/utils.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://services-sync/browserid_identity.js");
 Cu.import("resource://testing-common/services/common/logging.js");
 Cu.import("resource://testing-common/services/sync/fakeservices.js");
 Cu.import("resource://gre/modules/FxAccounts.jsm");
 Cu.import("resource://gre/modules/FxAccountsClient.jsm");
 Cu.import("resource://gre/modules/FxAccountsCommon.js");
-Cu.import("resource://gre/modules/Promise.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 
 // and grab non-exported stuff via a backstage pass.
 const {AccountState} = Cu.import("resource://gre/modules/FxAccounts.jsm", {});
 
 // A mock "storage manager" for FxAccounts that doesn't actually write anywhere.
 function MockFxaStorageManager() {
 }
@@ -91,16 +91,28 @@ this.waitForZeroTimer = function waitFor
       CommonUtils.nextTick(wait);
       return;
     }
     callback();
   }
   CommonUtils.namedTimer(wait, 150, {}, "timer");
 }
 
+this.promiseZeroTimer = function() {
+  return new Promise(resolve => {
+    waitForZeroTimer(resolve);
+  });
+}
+
+this.promiseNamedTimer = function(wait, thisObj, name) {
+  return new Promise(resolve => {
+    Utils.namedTimer(resolve, wait, thisObj, name);
+  });
+}
+
 /**
  * Return true if Sync is configured with the "legacy" identity provider.
  */
 this.isConfiguredWithLegacyIdentity = function() {
   let ns = {};
   Cu.import("resource://services-sync/service.js", ns);
 
   // We can't use instanceof as BrowserIDManager (the "other" identity) inherits
@@ -232,34 +244,31 @@ this.configureFxAccountIdentity = functi
   authService._fxaService = fxa;
   authService._tokenServerClient = mockTSC;
   // Set the "account" of the browserId manager to be the "email" of the
   // logged in user of the mockFXA service.
   authService._signedInUser = config.fxaccount.user;
   authService._account = config.fxaccount.user.email;
 }
 
-this.configureIdentity = function(identityOverrides) {
+this.configureIdentity = async function(identityOverrides) {
   let config = makeIdentityConfig(identityOverrides);
   let ns = {};
   Cu.import("resource://services-sync/service.js", ns);
 
   if (ns.Service.identity instanceof BrowserIDManager) {
     // do the FxAccounts thang...
     configureFxAccountIdentity(ns.Service.identity, config);
-    return ns.Service.identity.initializeWithCurrentIdentity().then(() => {
-      // need to wait until this identity manager is readyToAuthenticate.
-      return ns.Service.identity.whenReadyToAuthenticate.promise;
-    });
+    await ns.Service.identity.initializeWithCurrentIdentity();
+    // need to wait until this identity manager is readyToAuthenticate.
+    await ns.Service.identity.whenReadyToAuthenticate.promise;
+    return;
   }
   // old style identity provider.
   setBasicCredentials(config.username, config.sync.password, config.sync.syncKey);
-  let deferred = Promise.defer();
-  deferred.resolve();
-  return deferred.promise;
 }
 
 this.SyncTestingInfrastructure = function (server, username, password, syncKey) {
   let ns = {};
   Cu.import("resource://services-sync/service.js", ns);
 
   ensureLegacyIdentityManager();
   let config = makeIdentityConfig();
@@ -315,29 +324,29 @@ this.encryptPayload = function encryptPa
 this.add_identity_test = function(test, testFunction) {
   function note(what) {
     let msg = "running test " + testFunction.name + " with " + what + " identity manager";
     test.do_print(msg);
   }
   let ns = {};
   Cu.import("resource://services-sync/service.js", ns);
   // one task for the "old" identity manager.
-  test.add_task(function* () {
+  test.add_task(async function() {
     note("sync");
     let oldIdentity = Status._authManager;
     ensureLegacyIdentityManager();
-    yield testFunction();
+    await testFunction();
     Status.__authManager = ns.Service.identity = oldIdentity;
   });
   // another task for the FxAccounts identity manager.
-  test.add_task(function* () {
+  test.add_task(async function() {
     note("FxAccounts");
     let oldIdentity = Status._authManager;
     Status.__authManager = ns.Service.identity = new BrowserIDManager();
-    yield testFunction();
+    await testFunction();
     Status.__authManager = ns.Service.identity = oldIdentity;
   });
 }
 
 this.sumHistogram = function(name, options = {}) {
   let histogram = options.key ? Services.telemetry.getKeyedHistogramById(name) :
                   Services.telemetry.getHistogramById(name);
   let snapshot = histogram.snapshot(options.key);

--- a/services/sync/tests/unit/head_errorhandler_common.js
+++ b/services/sync/tests/unit/head_errorhandler_common.js
@@ -87,25 +87,21 @@ const EHTestsCommon = {
     // Make sync fail due to changed credentials. We simply re-encrypt
     // the keys with a different Sync Key, without changing the local one.
     let newSyncKeyBundle = new SyncKeyBundle("johndoe", "23456234562345623456234562");
     let keys = Service.collectionKeys.asWBO();
     keys.encrypt(newSyncKeyBundle);
     keys.upload(Service.resource(Service.cryptoKeysURL));
   },
 
-  setUp(server) {
-    return configureIdentity({ username: "johndoe" }).then(
-      () => {
-        Service.serverURL  = server.baseURI + "/";
-        Service.clusterURL = server.baseURI + "/";
-      }
-    ).then(
-      () => EHTestsCommon.generateAndUploadKeys()
-    );
+  async setUp(server) {
+    await configureIdentity({ username: "johndoe" });
+    Service.serverURL  = server.baseURI + "/";
+    Service.clusterURL = server.baseURI + "/";
+    return EHTestsCommon.generateAndUploadKeys()
   },
 
   generateAndUploadKeys() {
     generateNewKeys(Service.collectionKeys);
     let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
     serverKeys.encrypt(Service.identity.syncKeyBundle);
     return serverKeys.upload(Service.resource(Service.cryptoKeysURL)).success;
   }

--- a/services/sync/tests/unit/head_helpers.js
+++ b/services/sync/tests/unit/head_helpers.js
@@ -431,16 +431,37 @@ function sync_engine_and_validate_telem(
     if (caughtError) {
       Svc.Obs.notify("weave:service:sync:error", caughtError);
     } else {
       Svc.Obs.notify("weave:service:sync:finish");
     }
   });
 }
 
+// Returns a promise that resolves once the specified observer notification
+// has fired.
+function promiseOneObserver(topic, callback) {
+  return new Promise((resolve, reject) => {
+    let observer = function(subject, data) {
+      Svc.Obs.remove(topic, observer);
+      resolve({ subject: subject, data: data });
+    }
+    Svc.Obs.add(topic, observer)
+  });
+}
+
+function promiseStopServer(server) {
+  return new Promise(resolve => server.stop(resolve));
+}
+
+function promiseNextTick() {
+  return new Promise(resolve => {
+    Utils.nextTick(resolve);
+  });
+}
 // Avoid an issue where `client.name2` containing unicode characters causes
 // a number of tests to fail, due to them assuming that we do not need to utf-8
 // encode or decode data sent through the mocked server (see bug 1268912).
 Utils.getDefaultDeviceName = function() {
   return "Test device name";
 };
 
 

--- a/services/sync/tests/unit/test_bookmark_duping.js
+++ b/services/sync/tests/unit/test_bookmark_duping.js
@@ -18,26 +18,16 @@ const bms = PlacesUtils.bookmarks;
 
 Service.engineManager.register(BookmarksEngine);
 
 const engine = new BookmarksEngine(Service);
 const store = engine._store;
 store._log.level = Log.Level.Trace;
 engine._log.level = Log.Level.Trace;
 
-function promiseOneObserver(topic) {
-  return new Promise((resolve, reject) => {
-    let observer = function(subject, topic, data) {
-      Services.obs.removeObserver(observer, topic);
-      resolve({ subject: subject, data: data });
-    }
-    Services.obs.addObserver(observer, topic, false);
-  });
-}
-
 function setup() {
  let server = serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bookmarks: {version: engine.version,
                                           syncID: engine.syncID}}}},
     bookmarks: {},
   });
 
   generateNewKeys(Service.collectionKeys);
@@ -46,24 +36,24 @@ function setup() {
 
   let collection = server.user("foo").collection("bookmarks");
 
   Svc.Obs.notify("weave:engine:start-tracking");   // We skip usual startup...
 
   return { server, collection };
 }
 
-function* cleanup(server) {
+async function cleanup(server) {
   Svc.Obs.notify("weave:engine:stop-tracking");
   Services.prefs.setBoolPref("services.sync-testing.startOverKeepIdentity", true);
   let promiseStartOver = promiseOneObserver("weave:service:start-over:finish");
   Service.startOver();
-  yield promiseStartOver;
-  yield new Promise(resolve => server.stop(resolve));
-  yield bms.eraseEverything();
+  await promiseStartOver;
+  await promiseStopServer(server);
+  await bms.eraseEverything();
 }
 
 function getFolderChildrenIDs(folderId) {
   let index = 0;
   let result = [];
   while (true) {
     let childId = bms.getIdForItemAt(folderId, index);
     if (childId == -1) {
@@ -89,25 +79,25 @@ function createBookmark(parentId, url, t
 }
 
 function getServerRecord(collection, id) {
   let wbo = collection.get({ full: true, ids: [id] });
   // Whew - lots of json strings inside strings.
   return JSON.parse(JSON.parse(JSON.parse(wbo).payload).ciphertext);
 }
 
-function* promiseNoLocalItem(guid) {
+async function promiseNoLocalItem(guid) {
   // Check there's no item with the specified guid.
-  let got = yield bms.fetch({ guid });
+  let got = await bms.fetch({ guid });
   ok(!got, `No record remains with GUID ${guid}`);
   // and while we are here ensure the places cache doesn't still have it.
-  yield Assert.rejects(PlacesUtils.promiseItemId(guid));
+  await Assert.rejects(PlacesUtils.promiseItemId(guid));
 }
 
-function* validate(collection, expectedFailures = []) {
+async function validate(collection, expectedFailures = []) {
   let validator = new BookmarkValidator();
   let records = collection.payloads();
 
   let problems = validator.inspectServerRecords(records).problemData;
   // all non-zero problems.
   let summary = problems.getSummary().filter(prob => prob.count != 0);
 
   // split into 2 arrays - expected and unexpected.
@@ -126,23 +116,23 @@ function* validate(collection, expectedF
   }
   if (unexpected.length || expected.length != expectedFailures.length) {
     do_print("Validation failed:");
     do_print(JSON.stringify(summary));
     // print the entire validator output as it has IDs etc.
     do_print(JSON.stringify(problems, undefined, 2));
     // All server records and the entire bookmark tree.
     do_print("Server records:\n" + JSON.stringify(collection.payloads(), undefined, 2));
-    let tree = yield PlacesUtils.promiseBookmarksTree("", { includeItemIds: true });
+    let tree = await PlacesUtils.promiseBookmarksTree("", { includeItemIds: true });
     do_print("Local bookmark tree:\n" + JSON.stringify(tree, undefined, 2));
     ok(false);
   }
 }
 
-add_task(function* test_dupe_bookmark() {
+add_task(async function test_dupe_bookmark() {
   _("Ensure that a bookmark we consider a dupe is handled correctly.");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
     let {id: bmk1_id, guid: bmk1_guid} = createBookmark(folder1_id, "http://getfirefox.com/", "Get Firefox!");
@@ -168,32 +158,32 @@ add_task(function* test_dupe_bookmark() 
     _("Syncing so new dupe record is processed");
     engine.lastSync = engine.lastSync - 0.01;
     engine.sync();
 
     // We should have logically deleted the dupe record.
     equal(collection.count(), 7);
     ok(getServerRecord(collection, bmk1_guid).deleted);
     // and physically removed from the local store.
-    yield promiseNoLocalItem(bmk1_guid);
+    await promiseNoLocalItem(bmk1_guid);
     // Parent should still only have 1 item.
     equal(getFolderChildrenIDs(folder1_id).length, 1);
     // The parent record on the server should now reference the new GUID and not the old.
     let serverRecord = getServerRecord(collection, folder1_guid);
     ok(!serverRecord.children.includes(bmk1_guid));
     ok(serverRecord.children.includes(newGUID));
 
     // and a final sanity check - use the validator
-    yield validate(collection);
+    await validate(collection);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_reparented_bookmark() {
+add_task(async function test_dupe_reparented_bookmark() {
   _("Ensure that a bookmark we consider a dupe from a different parent is handled correctly");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
     let {id: bmk1_id, guid: bmk1_guid} = createBookmark(folder1_id, "http://getfirefox.com/", "Get Firefox!");
@@ -226,40 +216,40 @@ add_task(function* test_dupe_reparented_
     _("Syncing so new dupe record is processed");
     engine.lastSync = engine.lastSync - 0.01;
     engine.sync();
 
     // We should have logically deleted the dupe record.
     equal(collection.count(), 8);
     ok(getServerRecord(collection, bmk1_guid).deleted);
     // and physically removed from the local store.
-    yield promiseNoLocalItem(bmk1_guid);
+    await promiseNoLocalItem(bmk1_guid);
     // The original folder no longer has the item
     equal(getFolderChildrenIDs(folder1_id).length, 0);
     // But the second dupe folder does.
     equal(getFolderChildrenIDs(folder2_id).length, 1);
 
     // The record for folder1 on the server should reference neither old or new GUIDs.
     let serverRecord1 = getServerRecord(collection, folder1_guid);
     ok(!serverRecord1.children.includes(bmk1_guid));
     ok(!serverRecord1.children.includes(newGUID));
 
     // The record for folder2 on the server should only reference the new new GUID.
     let serverRecord2 = getServerRecord(collection, folder2_guid);
     ok(!serverRecord2.children.includes(bmk1_guid));
     ok(serverRecord2.children.includes(newGUID));
 
     // and a final sanity check - use the validator
-    yield validate(collection);
+    await validate(collection);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_reparented_locally_changed_bookmark() {
+add_task(async function test_dupe_reparented_locally_changed_bookmark() {
   _("Ensure that a bookmark with local changes we consider a dupe from a different parent is handled correctly");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
     let {id: bmk1_id, guid: bmk1_guid} = createBookmark(folder1_id, "http://getfirefox.com/", "Get Firefox!");
@@ -288,54 +278,54 @@ add_task(function* test_dupe_reparented_
     };
 
     collection.insert(newGUID, encryptPayload(to_apply), Date.now() / 1000 + 10);
 
     // Make a change to the bookmark that's a dupe, and set the modification
     // time further in the future than the incoming record. This will cause
     // us to issue the infamous "DATA LOSS" warning in the logs but cause us
     // to *not* apply the incoming record.
-    yield PlacesTestUtils.setBookmarkSyncFields({
+    await PlacesTestUtils.setBookmarkSyncFields({
       guid: bmk1_guid,
       syncChangeCounter: 1,
       lastModified: Date.now() + 60000,
     });
 
     _("Syncing so new dupe record is processed");
     engine.lastSync = engine.lastSync - 0.01;
     engine.sync();
 
     // We should have logically deleted the dupe record.
     equal(collection.count(), 8);
     ok(getServerRecord(collection, bmk1_guid).deleted);
     // and physically removed from the local store.
-    yield promiseNoLocalItem(bmk1_guid);
+    await promiseNoLocalItem(bmk1_guid);
     // The original folder still longer has the item
     equal(getFolderChildrenIDs(folder1_id).length, 1);
     // The second folder does not.
     equal(getFolderChildrenIDs(folder2_id).length, 0);
 
     // The record for folder1 on the server should reference only the GUID.
     let serverRecord1 = getServerRecord(collection, folder1_guid);
     ok(!serverRecord1.children.includes(bmk1_guid));
     ok(serverRecord1.children.includes(newGUID));
 
     // The record for folder2 on the server should reference nothing.
     let serverRecord2 = getServerRecord(collection, folder2_guid);
     ok(!serverRecord2.children.includes(bmk1_guid));
     ok(!serverRecord2.children.includes(newGUID));
 
     // and a final sanity check - use the validator
-    yield validate(collection);
+    await validate(collection);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_reparented_to_earlier_appearing_parent_bookmark() {
+add_task(async function test_dupe_reparented_to_earlier_appearing_parent_bookmark() {
   _("Ensure that a bookmark we consider a dupe from a different parent that " +
     "appears in the same sync before the dupe item");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
@@ -396,23 +386,23 @@ add_task(function* test_dupe_reparented_
 
     // Everything should be parented correctly.
     equal(getFolderChildrenIDs(folder1_id).length, 0);
     let newParentID = store.idForGUID(newParentGUID);
     let newID = store.idForGUID(newGUID);
     deepEqual(getFolderChildrenIDs(newParentID), [newID]);
 
     // Make sure the validator thinks everything is hunky-dory.
-    yield validate(collection);
+    await validate(collection);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_reparented_to_later_appearing_parent_bookmark() {
+add_task(async function test_dupe_reparented_to_later_appearing_parent_bookmark() {
   _("Ensure that a bookmark we consider a dupe from a different parent that " +
     "doesn't exist locally as we process the child, but does appear in the same sync");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
@@ -473,23 +463,23 @@ add_task(function* test_dupe_reparented_
     // The intended parent did end up existing, so it should be parented
     // correctly after de-duplication.
     equal(getFolderChildrenIDs(folder1_id).length, 0);
     let newParentID = store.idForGUID(newParentGUID);
     let newID = store.idForGUID(newGUID);
     deepEqual(getFolderChildrenIDs(newParentID), [newID]);
 
     // Make sure the validator thinks everything is hunky-dory.
-    yield validate(collection);
+    await validate(collection);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_reparented_to_future_arriving_parent_bookmark() {
+add_task(async function test_dupe_reparented_to_future_arriving_parent_bookmark() {
   _("Ensure that a bookmark we consider a dupe from a different parent that " +
     "doesn't exist locally and doesn't appear in this Sync is handled correctly");
 
   let { server, collection } = this.setup();
 
   try {
     // The parent folder and one bookmark in it.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
@@ -524,17 +514,17 @@ add_task(function* test_dupe_reparented_
     _("Syncing so new dupe record is processed");
     engine.lastSync = engine.lastSync - 0.01;
     engine.sync();
 
     // We should have logically deleted the dupe record.
     equal(collection.count(), 8);
     ok(getServerRecord(collection, bmk1_guid).deleted);
     // and physically removed from the local store.
-    yield promiseNoLocalItem(bmk1_guid);
+    await promiseNoLocalItem(bmk1_guid);
     // The intended parent doesn't exist, so it remains in the original folder
     equal(getFolderChildrenIDs(folder1_id).length, 1);
 
     // The record for folder1 on the server should reference the new GUID.
     let serverRecord1 = getServerRecord(collection, folder1_guid);
     ok(!serverRecord1.children.includes(bmk1_guid));
     ok(serverRecord1.children.includes(newGUID));
 
@@ -544,17 +534,17 @@ add_task(function* test_dupe_reparented_
           newParentGUID);
 
     // Check the validator. Sadly, this is known to cause a mismatch between
     // the server and client views of the tree.
     let expected = [
       // We haven't fixed the incoming record that referenced the missing parent.
       { name: "orphans", count: 1 },
     ];
-    yield validate(collection, expected);
+    await validate(collection, expected);
 
     // Now have the parent magically appear in a later sync - but
     // it appears as being in a different parent from our existing "Folder 1",
     // so the folder itself isn't duped.
     collection.insert(newParentGUID, encryptPayload({
       id: newParentGUID,
       type: "folder",
       title: "Folder 1",
@@ -592,24 +582,24 @@ add_task(function* test_dupe_reparented_
       // * Our original Folder1 was updated to include newGUID when it
       //   originally de-deuped and couldn't find the parent.
       // * When the parent *did* eventually arrive we used the parent annotation
       //   to correctly reparent - but that reparenting process does not change
       //   the server record.
       // Hence, newGUID is a child of both those server records :(
       { name: "multipleParents", count: 1 },
     ];
-    yield validate(collection, expected);
+    await validate(collection, expected);
 
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 
-add_task(function* test_dupe_empty_folder() {
+add_task(async function test_dupe_empty_folder() {
   _("Ensure that an empty folder we consider a dupe is handled correctly.");
   // Empty folders aren't particularly interesting in practice (as that seems
   // an edge-case) but duping folders with items is broken - bug 1293163.
   let { server, collection } = this.setup();
 
   try {
     // The folder we will end up duping away.
     let {id: folder1_id, guid: folder1_guid } = createFolder(bms.toolbarFolder, "Folder 1");
@@ -629,20 +619,20 @@ add_task(function* test_dupe_empty_folde
       parentid: "toolbar",
       children: [],
     }), Date.now() / 1000 + 10);
 
     _("Syncing so new dupe records are processed");
     engine.lastSync = engine.lastSync - 0.01;
     engine.sync();
 
-    yield validate(collection);
+    await validate(collection);
 
     // Collection now has one additional record - the logically deleted dupe.
     equal(collection.count(), 6);
     // original folder should be logically deleted.
     ok(getServerRecord(collection, folder1_guid).deleted);
-    yield promiseNoLocalItem(folder1_guid);
+    await promiseNoLocalItem(folder1_guid);
   } finally {
-    yield cleanup(server);
+    await cleanup(server);
   }
 });
 // XXX - TODO - folders with children. Bug 1293163

--- a/services/sync/tests/unit/test_bookmark_engine.js
+++ b/services/sync/tests/unit/test_bookmark_engine.js
@@ -6,31 +6,30 @@ Cu.import("resource://gre/modules/Places
 Cu.import("resource://gre/modules/BookmarkJSONUtils.jsm");
 Cu.import("resource://gre/modules/Log.jsm");
 Cu.import("resource://services-sync/constants.js");
 Cu.import("resource://services-sync/engines.js");
 Cu.import("resource://services-sync/engines/bookmarks.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
-Cu.import("resource://gre/modules/Promise.jsm");
 
 initTestLogging("Trace");
 
 Service.engineManager.register(BookmarksEngine);
 
-function* assertChildGuids(folderGuid, expectedChildGuids, message) {
-  let tree = yield PlacesUtils.promiseBookmarksTree(folderGuid);
+async function assertChildGuids(folderGuid, expectedChildGuids, message) {
+  let tree = await PlacesUtils.promiseBookmarksTree(folderGuid);
   let childGuids = tree.children.map(child => child.guid);
   deepEqual(childGuids, expectedChildGuids, message);
 }
 
-function* fetchAllSyncIds() {
-  let db = yield PlacesUtils.promiseDBConnection();
-  let rows = yield db.executeCached(`
+async function fetchAllSyncIds() {
+  let db = await PlacesUtils.promiseDBConnection();
+  let rows = await db.executeCached(`
     WITH RECURSIVE
     syncedItems(id, guid) AS (
       SELECT b.id, b.guid FROM moz_bookmarks b
       WHERE b.guid IN ('menu________', 'toolbar_____', 'unfiled_____',
                        'mobile______')
       UNION ALL
       SELECT b.id, b.guid FROM moz_bookmarks b
       JOIN syncedItems s ON b.parent = s.id
@@ -40,17 +39,17 @@ function* fetchAllSyncIds() {
   for (let row of rows) {
     let syncId = PlacesSyncUtils.bookmarks.guidToSyncId(
       row.getResultByName("guid"));
     syncIds.add(syncId);
   }
   return syncIds;
 }
 
-add_task(function* test_delete_invalid_roots_from_server() {
+add_task(async function test_delete_invalid_roots_from_server() {
   _("Ensure that we delete the Places and Reading List roots from the server.");
 
   let engine  = new BookmarksEngine(Service);
   let store   = engine._store;
   let tracker = engine._tracker;
   let server = serverForFoo(engine);
   new SyncTestingInfrastructure(server.server);
 
@@ -80,51 +79,51 @@ add_task(function* test_delete_invalid_r
     newBmk.title = "Get Firefox!";
     newBmk.parentName = "Bookmarks Toolbar";
     newBmk.parentid = "toolbar";
     collection.insert(newBmk.id, encryptPayload(newBmk.cleartext));
 
     deepEqual(collection.keys().sort(), ["places", "readinglist", listBmk.id, newBmk.id].sort(),
       "Should store Places root, reading list items, and new bookmark on server");
 
-    yield sync_engine_and_validate_telem(engine, false);
+    await sync_engine_and_validate_telem(engine, false);
 
     ok(!store.itemExists("readinglist"), "Should not apply Reading List root");
     ok(!store.itemExists(listBmk.id), "Should not apply items in Reading List");
     ok(store.itemExists(newBmk.id), "Should apply new bookmark");
 
     deepEqual(collection.keys().sort(), ["menu", "mobile", "toolbar", "unfiled", newBmk.id].sort(),
       "Should remove Places root and reading list items from server; upload local roots");
   } finally {
     store.wipe();
     Svc.Prefs.resetBranch("");
     Service.recordManager.clearCache();
-    yield new Promise(resolve => server.stop(resolve));
+    await promiseStopServer(server);
     Svc.Obs.notify("weave:engine:stop-tracking");
   }
 });
 
-add_task(function* test_change_during_sync() {
+add_task(async function test_change_during_sync() {
   _("Ensure that we track changes made during a sync.");
 
   let engine  = new BookmarksEngine(Service);
   let store   = engine._store;
   let tracker = engine._tracker;
   let server = serverForFoo(engine);
   new SyncTestingInfrastructure(server.server);
 
   let collection = server.user("foo").collection("bookmarks");
 
   let bz_id = PlacesUtils.bookmarks.insertBookmark(
     PlacesUtils.bookmarksMenuFolderId, Utils.makeURI("https://bugzilla.mozilla.org/"),
     PlacesUtils.bookmarks.DEFAULT_INDEX, "Bugzilla");
-  let bz_guid = yield PlacesUtils.promiseItemGuid(bz_id);
+  let bz_guid = await PlacesUtils.promiseItemGuid(bz_id);
     _(`Bugzilla GUID: ${bz_guid}`);
 
-  yield PlacesTestUtils.markBookmarksAsSynced();
+  await PlacesTestUtils.markBookmarksAsSynced();
   Svc.Obs.notify("weave:engine:start-tracking");
 
   try {
     let folder1_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.toolbarFolder, "Folder 1", 0);
     let folder1_guid = store.GUIDForId(folder1_id);
     _(`Folder GUID: ${folder1_guid}`);
 
@@ -194,72 +193,72 @@ add_task(function* test_change_during_sy
       localTaggedBmk.bmkUri     = "https://example.org";
       localTaggedBmk.title      = "Tagged bookmark";
       localTaggedBmk.tags       = ["taggy"];
       localTaggedBmk.parentName = "Folder 2";
       localTaggedBmk.parentid   = folder2_guid;
       collection.insert(bmk4_guid, encryptPayload(localTaggedBmk.cleartext));
     }
 
-    yield* assertChildGuids(folder1_guid, [bmk1_guid], "Folder should have 1 child before first sync");
+    await assertChildGuids(folder1_guid, [bmk1_guid], "Folder should have 1 child before first sync");
 
     _("Perform first sync");
     {
       let changes = engine.pullNewChanges();
       deepEqual(changes.ids().sort(), [folder1_guid, bmk1_guid, "toolbar"].sort(),
         "Should track bookmark and folder created before first sync");
-      yield sync_engine_and_validate_telem(engine, false);
+      await sync_engine_and_validate_telem(engine, false);
     }
 
     let bmk2_id = store.idForGUID(bmk2_guid);
     let bmk3_guid = store.GUIDForId(bmk3_id);
     _(`Mozilla GUID: ${bmk3_guid}`);
     {
       equal(store.GUIDForId(bmk2_id), bmk2_guid,
         "Remote bookmark should be applied during first sync");
       ok(bmk3_id > -1,
         "Bookmark created during first sync should exist locally");
       ok(!collection.wbo(bmk3_guid),
         "Bookmark created during first sync shouldn't be uploaded yet");
 
-      yield* assertChildGuids(folder1_guid, [bmk1_guid, bmk3_guid, bmk2_guid],
+      await assertChildGuids(folder1_guid, [bmk1_guid, bmk3_guid, bmk2_guid],
         "Folder 1 should have 3 children after first sync");
-      yield* assertChildGuids(folder2_guid, [bmk4_guid, tagQuery_guid],
+      await assertChildGuids(folder2_guid, [bmk4_guid, tagQuery_guid],
         "Folder 2 should have 2 children after first sync");
       let taggedURIs = PlacesUtils.tagging.getURIsForTag("taggy");
       equal(taggedURIs.length, 1, "Should have 1 tagged URI");
       equal(taggedURIs[0].spec, "https://example.org/",
         "Synced tagged bookmark should appear in tagged URI list");
     }
 
     _("Perform second sync");
     {
       let changes = engine.pullNewChanges();
       deepEqual(changes.ids().sort(), [bmk3_guid, folder1_guid].sort(),
         "Should track bookmark added during last sync and its parent");
-      yield sync_engine_and_validate_telem(engine, false);
+      await sync_engine_and_validate_telem(engine, false);
 
       ok(collection.wbo(bmk3_guid),
         "Bookmark created during first sync should be uploaded during second sync");
 
-      yield* assertChildGuids(folder1_guid, [bmk1_guid, bmk3_guid, bmk2_guid],
+      await assertChildGuids(folder1_guid, [bmk1_guid, bmk3_guid, bmk2_guid],
         "Folder 1 should have same children after second sync");
-      yield* assertChildGuids(folder2_guid, [bmk4_guid, tagQuery_guid],
+      await assertChildGuids(folder2_guid, [bmk4_guid, tagQuery_guid],
         "Folder 2 should have same children after second sync");
     }
   } finally {
     store.wipe();
     Svc.Prefs.resetBranch("");
     Service.recordManager.clearCache();
-    yield new Promise(resolve => server.stop(resolve));
+    await promiseStopServer(server);
     Svc.Obs.notify("weave:engine:stop-tracking");
   }
 });
 
-add_task(function* bad_record_allIDs() {
+add_task(async function bad_record_allIDs() {
   let server = new SyncServer();
   server.start();
   let syncTesting = new SyncTestingInfrastructure(server.server);
 
   _("Ensure that bad Places queries don't cause an error in getAllIDs.");
   let engine = new BookmarksEngine(Service);
   let store = engine._store;
   let badRecordID = PlacesUtils.bookmarks.insertBookmark(
@@ -268,37 +267,37 @@ add_task(function* bad_record_allIDs() {
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       null);
 
   do_check_true(badRecordID > 0);
   _("Record is " + badRecordID);
   _("Type: " + PlacesUtils.bookmarks.getItemType(badRecordID));
 
   _("Fetching all IDs.");
-  let all = yield* fetchAllSyncIds();
+  let all = await fetchAllSyncIds();
 
   _("All IDs: " + JSON.stringify([...all]));
   do_check_true(all.has("menu"));
   do_check_true(all.has("toolbar"));
 
   _("Clean up.");
   PlacesUtils.bookmarks.removeItem(badRecordID);
-  yield PlacesSyncUtils.bookmarks.reset();
-  yield new Promise(r => server.stop(r));
+  await PlacesSyncUtils.bookmarks.reset();
+  await promiseStopServer(server);
 });
 
 function serverForFoo(engine) {
   return serverForUsers({"foo": "password"}, {
     meta: {global: {engines: {bookmarks: {version: engine.version,
                                           syncID: engine.syncID}}}},
     bookmarks: {}
   });
 }
 
-add_task(function* test_processIncoming_error_orderChildren() {
+add_task(async function test_processIncoming_error_orderChildren() {
   _("Ensure that _orderChildren() is called even when _processIncoming() throws an error.");
 
   let engine = new BookmarksEngine(Service);
   let store  = engine._store;
   let server = serverForFoo(engine);
   new SyncTestingInfrastructure(server.server);
 
   let collection = server.user("foo").collection("bookmarks");
@@ -335,17 +334,17 @@ add_task(function* test_processIncoming_
 
     // Make the 10 minutes old so it will only be synced in the toFetch phase.
     bogus_record.modified = Date.now() / 1000 - 60 * 10;
     engine.lastSync = Date.now() / 1000 - 60;
     engine.toFetch = [BOGUS_GUID];
 
     let error;
     try {
-      yield sync_engine_and_validate_telem(engine, true)
+      await sync_engine_and_validate_telem(engine, true)
     } catch(ex) {
       error = ex;
     }
     ok(!!error);
 
     // Verify that the bookmark order has been applied.
     let new_children = store.createRecord(folder1_guid).children;
     do_check_eq(new_children.length, 2);
@@ -354,22 +353,22 @@ add_task(function* test_processIncoming_
 
     do_check_eq(PlacesUtils.bookmarks.getItemIndex(bmk1_id), 1);
     do_check_eq(PlacesUtils.bookmarks.getItemIndex(bmk2_id), 0);
 
   } finally {
     store.wipe();
     Svc.Prefs.resetBranch("");
     Service.recordManager.clearCache();
-    yield PlacesSyncUtils.bookmarks.reset();
-    yield new Promise(resolve => server.stop(resolve));
+    await PlacesSyncUtils.bookmarks.reset();
+    await promiseStopServer(server);
   }
 });
 
-add_task(function* test_restorePromptsReupload() {
+add_task(async function test_restorePromptsReupload() {
   _("Ensure that restoring from a backup will reupload all records.");
   let engine = new BookmarksEngine(Service);
   let store  = engine._store;
   let server = serverForFoo(engine);
   new SyncTestingInfrastructure(server.server);
 
   let collection = server.user("foo").collection("bookmarks");
 
@@ -396,48 +395,48 @@ add_task(function* test_restorePromptsRe
       .getService(Ci.nsIProperties);
 
     let backupFile = dirSvc.get("TmpD", Ci.nsILocalFile);
 
     _("Make a backup.");
     backupFile.append("t_b_e_" + Date.now() + ".json");
 
     _("Backing up to file " + backupFile.path);
-    yield BookmarkJSONUtils.exportToFile(backupFile.path);
+    await BookmarkJSONUtils.exportToFile(backupFile.path);
 
     _("Create a different record and sync.");
     let bmk2_id = PlacesUtils.bookmarks.insertBookmark(
       folder1_id, tburi, PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Thunderbird!");
     let bmk2_guid = store.GUIDForId(bmk2_id);
     _("Get Thunderbird!: " + bmk2_id + ", " + bmk2_guid);
 
     PlacesUtils.bookmarks.removeItem(bmk1_id);
 
     let error;
     try {
-      yield sync_engine_and_validate_telem(engine, false);
+      await sync_engine_and_validate_telem(engine, false);
     } catch(ex) {
       error = ex;
       _("Got error: " + Log.exceptionStr(ex));
     }
     do_check_true(!error);
 
     _("Verify that there's only one bookmark on the server, and it's Thunderbird.");
     // Of course, there's also the Bookmarks Toolbar and Bookmarks Menu...
     let wbos = collection.keys(function (id) {
       return ["menu", "toolbar", "mobile", "unfiled", folder1_guid].indexOf(id) == -1;
     });
     do_check_eq(wbos.length, 1);
     do_check_eq(wbos[0], bmk2_guid);
 
     _("Now restore from a backup.");
-    yield BookmarkJSONUtils.importFromFile(backupFile, true);
+    await BookmarkJSONUtils.importFromFile(backupFile, true);
 
     _("Ensure we have the bookmarks we expect locally.");
-    let guids = yield* fetchAllSyncIds();
+    let guids = await fetchAllSyncIds();
     _("GUIDs: " + JSON.stringify([...guids]));
     let found = false;
     let count = 0;
     let newFX;
     for (let guid of guids) {
       count++;
       let id = store.idForGUID(guid, true);
       // Only one bookmark, so _all_ should be Firefox!
@@ -452,17 +451,17 @@ add_task(function* test_restorePromptsRe
     _("We found it: " + found);
     do_check_true(found);
 
     _("Have the correct number of IDs locally, too.");
     do_check_eq(count, ["menu", "toolbar", "mobile", "unfiled", folder1_id, bmk1_id].length);
 
     _("Sync again. This'll wipe bookmarks from the server.");
     try {
-      yield sync_engine_and_validate_telem(engine, false);
+      await sync_engine_and_validate_telem(engine, false);
     } catch(ex) {
       error = ex;
       _("Got error: " + Log.exceptionStr(ex));
     }
     do_check_true(!error);
 
     _("Verify that there's only one bookmark on the server, and it's Firefox.");
     // Of course, there's also the Bookmarks Toolbar and Bookmarks Menu...
@@ -486,32 +485,32 @@ add_task(function* test_restorePromptsRe
     _("Our old friend Folder 1 is still in play.");
     do_check_eq(folderWBOs.length, 1);
     do_check_eq(folderWBOs[0].title, "Folder 1");
 
   } finally {
     store.wipe();
     Svc.Prefs.resetBranch("");
     Service.recordManager.clearCache();
-    yield PlacesSyncUtils.bookmarks.reset();
-    yield new Promise(r => server.stop(r));
+    await PlacesSyncUtils.bookmarks.reset();
+    await promiseStopServer(server);
   }
 });
 
 function FakeRecord(constructor, r) {
   constructor.call(this, "bookmarks", r.id);
   for (let x in r) {
     this[x] = r[x];
   }
   // Borrow the constructor's conversion functions.
   this.toSyncBookmark = constructor.prototype.toSyncBookmark;
 }
 
 // Bug 632287.
-add_task(function* test_mismatched_types() {
+add_task(async function test_mismatched_types() {
   _("Ensure that handling a record that changes type causes deletion " +
     "then re-adding.");
 
   let oldRecord = {
     "id": "l1nZZXfB8nC7",
     "type":"folder",
     "parentName":"Bookmarks Toolbar",
     "title":"Innerst i Sneglehode",
@@ -566,22 +565,22 @@ add_task(function* test_mismatched_types
     do_check_eq(bms.getItemType(newID), bms.TYPE_FOLDER);
     do_check_true(PlacesUtils.annotations
                              .itemHasAnnotation(newID, PlacesUtils.LMANNO_FEEDURI));
 
   } finally {
     store.wipe();
     Svc.Prefs.resetBranch("");
     Service.recordManager.clearCache();
-    yield PlacesSyncUtils.bookmarks.reset();
-    yield new Promise(r => server.stop(r));
+    await PlacesSyncUtils.bookmarks.reset();
+    await promiseStopServer(server);
   }
 });
 
-add_task(function* test_bookmark_guidMap_fail() {
+add_task(async function test_bookmark_guidMap_fail() {
   _("Ensure that failures building the GUID map cause early death.");
 
   let engine = new BookmarksEngine(Service);
   let store = engine._store;
 
   let server = serverForFoo(engine);
   let coll   = server.user("foo").collection("bookmarks");
   new SyncTestingInfrastructure(server.server);
@@ -620,44 +619,44 @@ add_task(function* test_bookmark_guidMap
   try {
     engine._processIncoming();
   } catch (ex) {
     err = ex;
   }
   do_check_eq(err, "Nooo");
 
   PlacesUtils.promiseBookmarksTree = pbt;
-  yield PlacesSyncUtils.bookmarks.reset();
-  yield new Promise(r => server.stop(r));
+  await PlacesSyncUtils.bookmarks.reset();
+  await promiseStopServer(server);
 });
 
-add_task(function* test_bookmark_tag_but_no_uri() {
+add_task(async function test_bookmark_tag_but_no_uri() {
   _("Ensure that a bookmark record with tags, but no URI, doesn't throw an exception.");
 
   let engine = new BookmarksEngine(Service);
   let store = engine._store;
 
   // We're simply checking that no exception is thrown, so
   // no actual checks in this test.
 
-  yield PlacesSyncUtils.bookmarks.insert({
+  await PlacesSyncUtils.bookmarks.insert({
     kind: PlacesSyncUtils.bookmarks.KINDS.BOOKMARK,
     syncId: Utils.makeGUID(),
     parentSyncId: "toolbar",
     url: "http://example.com",
     tags: ["foo"],
   });
-  yield PlacesSyncUtils.bookmarks.insert({
+  await PlacesSyncUtils.bookmarks.insert({
     kind: PlacesSyncUtils.bookmarks.KINDS.BOOKMARK,
     syncId: Utils.makeGUID(),
     parentSyncId: "toolbar",
     url: "http://example.org",
     tags: null,
   });
-  yield PlacesSyncUtils.bookmarks.insert({
+  await PlacesSyncUtils.bookmarks.insert({
     kind: PlacesSyncUtils.bookmarks.KINDS.BOOKMARK,
     syncId: Utils.makeGUID(),
     url: "about:fake",
     parentSyncId: "toolbar",
     tags: null,
   });
 
   let record = new FakeRecord(BookmarkFolder, {
@@ -669,17 +668,17 @@ add_task(function* test_bookmark_tag_but
     type:        "folder"
   });
 
   store.create(record);
   record.tags = ["bar"];
   store.update(record);
 });
 
-add_task(function* test_misreconciled_root() {
+add_task(async function test_misreconciled_root() {
   _("Ensure that we don't reconcile an arbitrary record with a root.");
 
   let engine = new BookmarksEngine(Service);
   let store = engine._store;
   let server = serverForFoo(engine);
 
   // Log real hard for this test.
   store._log.trace = store._log.debug;
@@ -733,17 +732,17 @@ add_task(function* test_misreconciled_ro
   // the real GUID, instead using a generated one. Sync does the translation.
   let toolbarAfter = store.createRecord("toolbar", "bookmarks");
   let parentGUIDAfter = toolbarAfter.parentid;
   let parentIDAfter = store.idForGUID(parentGUIDAfter);
   do_check_eq(store.GUIDForId(toolbarIDBefore), "toolbar");
   do_check_eq(parentGUIDBefore, parentGUIDAfter);
   do_check_eq(parentIDBefore, parentIDAfter);
 
-  yield PlacesSyncUtils.bookmarks.reset();
-  yield new Promise(r => server.stop(r));
+  await PlacesSyncUtils.bookmarks.reset();
+  await promiseStopServer(server);
 });
 
 function run_test() {
   initTestLogging("Trace");
   generateNewKeys(Service.collectionKeys);
   run_next_test();
 }

--- a/services/sync/tests/unit/test_bookmark_invalid.js
+++ b/services/sync/tests/unit/test_bookmark_invalid.js
@@ -1,61 +1,60 @@
 Cu.import("resource://gre/modules/PlacesUtils.jsm");
 Cu.import("resource://gre/modules/Log.jsm");
-Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://services-sync/engines.js");
 Cu.import("resource://services-sync/engines/bookmarks.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 
 Service.engineManager.register(BookmarksEngine);
 
 var engine = Service.engineManager.get("bookmarks");
 var store = engine._store;
 var tracker = engine._tracker;
 
-add_task(function* test_ignore_invalid_uri() {
+add_task(async function test_ignore_invalid_uri() {
   _("Ensure that we don't die with invalid bookmarks.");
 
   // First create a valid bookmark.
   let bmid = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
                                                   Services.io.newURI("http://example.com/", null, null),
                                                   PlacesUtils.bookmarks.DEFAULT_INDEX,
                                                   "the title");
 
   // Now update moz_places with an invalid url.
-  yield PlacesUtils.withConnectionWrapper("test_ignore_invalid_uri", Task.async(function* (db) {
-    yield db.execute(
+  await PlacesUtils.withConnectionWrapper("test_ignore_invalid_uri", async function(db) {
+    await db.execute(
       `UPDATE moz_places SET url = :url, url_hash = hash(:url)
        WHERE id = (SELECT b.fk FROM moz_bookmarks b
        WHERE b.id = :id LIMIT 1)`,
       { id: bmid, url: "<invalid url>" });
-  }));
+  });
 
   // Ensure that this doesn't throw even though the DB is now in a bad state (a
   // bookmark has an illegal url).
   engine._buildGUIDMap();
 });
 
-add_task(function* test_ignore_missing_uri() {
+add_task(async function test_ignore_missing_uri() {
   _("Ensure that we don't die with a bookmark referencing an invalid bookmark id.");
 
   // First create a valid bookmark.
   let bmid = PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
                                                   Services.io.newURI("http://example.com/", null, null),
                                                   PlacesUtils.bookmarks.DEFAULT_INDEX,
                                                   "the title");
 
   // Now update moz_bookmarks to reference a non-existing places ID
-  yield PlacesUtils.withConnectionWrapper("test_ignore_missing_uri", Task.async(function* (db) {
-    yield db.execute(
+  await PlacesUtils.withConnectionWrapper("test_ignore_missing_uri", async function(db) {
+    await db.execute(
       `UPDATE moz_bookmarks SET fk = 999999
        WHERE id = :id`
       , { id: bmid });
-  }));
+  });
 
   // Ensure that this doesn't throw even though the DB is now in a bad state (a
   // bookmark has an illegal url).
   engine._buildGUIDMap();
 });
 
 function run_test() {
   initTestLogging('Trace');

--- a/services/sync/tests/unit/test_bookmark_order.js
+++ b/services/sync/tests/unit/test_bookmark_order.js
@@ -1,20 +1,19 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 _("Making sure after processing incoming bookmarks, they show up in the right order");
 Cu.import("resource://gre/modules/PlacesUtils.jsm");
-Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://services-sync/engines/bookmarks.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 
-var check = Task.async(function* (expected, message) {
-  let root = yield PlacesUtils.promiseBookmarksTree();
+var check = async function(expected, message) {
+  let root = await PlacesUtils.promiseBookmarksTree();
 
   let bookmarks = (function mapTree(children) {
     return children.map(child => {
       let result = {
         guid: child.guid,
         index: child.index,
       };
       if (child.children) {
@@ -29,25 +28,25 @@ var check = Task.async(function* (expect
       }
       return result;
     });
   }(root.children));
 
   _("Checking if the bookmark structure is", JSON.stringify(expected));
   _("Got bookmarks:", JSON.stringify(bookmarks));
   deepEqual(bookmarks, expected);
-});
+};
 
-add_task(function* test_bookmark_order() {
+add_task(async function test_bookmark_order() {
   let store = new BookmarksEngine(Service)._store;
   initTestLogging("Trace");
 
   _("Starting with a clean slate of no bookmarks");
   store.wipe();
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     // Index 2 is the tags root. (Root indices depend on the order of the
     // `CreateRoot` calls in `Database::CreateBookmarkRoots`).
@@ -81,17 +80,17 @@ add_task(function* test_bookmark_order()
     store._childrenToOrder = {};
     store.applyIncoming(record);
     store._orderChildren();
     delete store._childrenToOrder;
   }
   let id10 = "10_aaaaaaaaa";
   _("basic add first bookmark");
   apply(bookmark(id10, ""));
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -101,17 +100,17 @@ add_task(function* test_bookmark_order()
     }],
   }, {
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "basic add first bookmark");
   let id20 = "20_aaaaaaaaa";
   _("basic append behind 10");
   apply(bookmark(id20, ""));
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -128,17 +127,17 @@ add_task(function* test_bookmark_order()
   }], "basic append behind 10");
 
   let id31 = "31_aaaaaaaaa";
   let id30 = "f30_aaaaaaaa";
   _("basic create in folder");
   apply(bookmark(id31, id30));
   let f30 = folder(id30, "", [id31]);
   apply(f30);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -160,17 +159,17 @@ add_task(function* test_bookmark_order()
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "basic create in folder");
 
   let id41 = "41_aaaaaaaaa";
   let id40 = "f40_aaaaaaaa";
   _("insert missing parent -> append to unfiled");
   apply(bookmark(id41, id40));
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -196,17 +195,17 @@ add_task(function* test_bookmark_order()
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "insert missing parent -> append to unfiled");
 
   let id42 = "42_aaaaaaaaa";
 
   _("insert another missing parent -> append");
   apply(bookmark(id42, id40));
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -235,17 +234,17 @@ add_task(function* test_bookmark_order()
   }, {
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "insert another missing parent -> append");
 
   _("insert folder -> move children and followers");
   let f40 = folder(id40, "", [id41, id42]);
   apply(f40);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -276,17 +275,17 @@ add_task(function* test_bookmark_order()
   }, {
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "insert folder -> move children and followers");
 
   _("Moving 41 behind 42 -> update f40");
   f40.children = [id42, id41];
   apply(f40);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -317,17 +316,17 @@ add_task(function* test_bookmark_order()
   }, {
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "Moving 41 behind 42 -> update f40");
 
   _("Moving 10 back to front -> update 10, 20");
   f40.children = [id41, id42];
   apply(f40);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -357,17 +356,17 @@ add_task(function* test_bookmark_order()
     }],
   }, {
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "Moving 10 back to front -> update 10, 20");
 
   _("Moving 20 behind 42 in f40 -> update 50");
   apply(bookmark(id20, id40));
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -399,17 +398,17 @@ add_task(function* test_bookmark_order()
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "Moving 20 behind 42 in f40 -> update 50");
 
   _("Moving 10 in front of 31 in f30 -> update 10, f30");
   apply(bookmark(id10, id30));
   f30.children = [id10, id31];
   apply(f30);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -441,17 +440,17 @@ add_task(function* test_bookmark_order()
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "Moving 10 in front of 31 in f30 -> update 10, f30");
 
   _("Moving 20 from f40 to f30 -> update 20, f30");
   apply(bookmark(id20, id30));
   f30.children = [id10, id20, id31];
   apply(f30);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,
@@ -483,17 +482,17 @@ add_task(function* test_bookmark_order()
     guid: PlacesUtils.bookmarks.mobileGuid,
     index: 4,
   }], "Moving 20 from f40 to f30 -> update 20, f30");
 
   _("Move 20 back to front -> update 20, f30");
   apply(bookmark(id20, ""));
   f30.children = [id10, id31];
   apply(f30);
-  yield check([{
+  await check([{
     guid: PlacesUtils.bookmarks.menuGuid,
     index: 0,
   }, {
     guid: PlacesUtils.bookmarks.toolbarGuid,
     index: 1,
   }, {
     guid: PlacesUtils.bookmarks.unfiledGuid,
     index: 3,

--- a/services/sync/tests/unit/test_bookmark_smart_bookmarks.js
+++ b/services/sync/tests/unit/test_bookmark_smart_bookmarks.js
@@ -52,17 +52,17 @@ function serverForFoo(engine) {
     meta: {global: {engines: {bookmarks: {version: engine.version,
                                           syncID: engine.syncID}}}},
     bookmarks: {}
   });
 }
 
 // Verify that Places smart bookmarks have their annotation uploaded and
 // handled locally.
-add_task(function *test_annotation_uploaded() {
+add_task(async function test_annotation_uploaded() {
   let server = serverForFoo(engine);
   new SyncTestingInfrastructure(server.server);
 
   let startCount = smartBookmarkCount();
 
   _("Start count is " + startCount);
 
   if (startCount > 0) {
@@ -105,17 +105,17 @@ add_task(function *test_annotation_uploa
 
   _("Our count has increased since we started.");
   do_check_eq(smartBookmarkCount(), startCount + 1);
 
   _("Sync record to the server.");
   let collection = server.user("foo").collection("bookmarks");
 
   try {
-    yield sync_engine_and_validate_telem(engine, false);
+    await sync_engine_and_validate_telem(engine, false);
     let wbos = collection.keys(function (id) {
                  return ["menu", "toolbar", "mobile", "unfiled"].indexOf(id) == -1;
                });
     do_check_eq(wbos.length, 1);
 
     _("Verify that the server WBO has the annotation.");
     let serverGUID = wbos[0];
     do_check_eq(serverGUID, guid);
@@ -136,17 +136,17 @@ add_task(function *test_annotation_uploa
       mostVisitedID, Utils.makeURI("http://something/else"));
     PlacesUtils.annotations.removeItemAnnotation(mostVisitedID,
                                                  SMART_BOOKMARKS_ANNO);
     store.wipe();
     engine.resetClient();
     do_check_eq(smartBookmarkCount(), startCount);
 
     _("Sync. Verify that the downloaded record carries the annotation.");
-    yield sync_engine_and_validate_telem(engine, false);
+    await sync_engine_and_validate_telem(engine, false);
 
     _("Verify that the Places DB now has an annotated bookmark.");
     _("Our count has increased again.");
     do_check_eq(smartBookmarkCount(), startCount + 1);
 
     _("Find by GUID and verify that it's annotated.");
     let newID = store.idForGUID(serverGUID);
     let newAnnoValue = PlacesUtils.annotations.getItemAnnotation(

--- a/services/sync/tests/unit/test_bookmark_store.js
+++ b/services/sync/tests/unit/test_bookmark_store.js
@@ -16,36 +16,36 @@ var store = engine._store;
 var tracker = engine._tracker;
 
 // Don't write some persistence files asynchronously.
 tracker.persistChangedIDs = false;
 
 var fxuri = Utils.makeURI("http://getfirefox.com/");
 var tburi = Utils.makeURI("http://getthunderbird.com/");
 
-add_task(function* test_ignore_specials() {
+add_task(async function test_ignore_specials() {
   _("Ensure that we can't delete bookmark roots.");
 
   // Belt...
   let record = new BookmarkFolder("bookmarks", "toolbar", "folder");
   record.deleted = true;
   do_check_neq(null, store.idForGUID("toolbar"));
 
   store.applyIncoming(record);
-  yield store.deletePending();
+  await store.deletePending();
 
   // Ensure that the toolbar exists.
   do_check_neq(null, store.idForGUID("toolbar"));
 
   // This will fail painfully in getItemType if the deletion worked.
   engine._buildGUIDMap();
 
   // Braces...
   store.remove(record);
-  yield store.deletePending();
+  await store.deletePending();
   do_check_neq(null, store.idForGUID("toolbar"));
   engine._buildGUIDMap();
 
   store.wipe();
 });
 
 add_test(function test_bookmark_create() {
   try {
@@ -239,29 +239,29 @@ add_test(function test_folder_createReco
 
   } finally {
     _("Clean up.");
     store.wipe();
     run_next_test();
   }
 });
 
-add_task(function* test_deleted() {
+add_task(async function test_deleted() {
   try {
     _("Create a bookmark that will be deleted.");
     let bmk1_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.toolbarFolder, fxuri,
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let bmk1_guid = store.GUIDForId(bmk1_id);
 
     _("Delete the bookmark through the store.");
     let record = new PlacesItem("bookmarks", bmk1_guid);
     record.deleted = true;
     store.applyIncoming(record);
-    yield store.deletePending();
+    await store.deletePending();
     _("Ensure it has been deleted.");
     let error;
     try {
       PlacesUtils.bookmarks.getBookmarkURI(bmk1_id);
     } catch(ex) {
       error = ex;
     }
     do_check_eq(error.result, Cr.NS_ERROR_ILLEGAL_VALUE);
@@ -433,19 +433,19 @@ function assertDeleted(id) {
   try {
     PlacesUtils.bookmarks.getItemType(id);
   } catch (e) {
     error = e;
   }
   equal(error.result, Cr.NS_ERROR_ILLEGAL_VALUE)
 }
 
-add_task(function* test_delete_buffering() {
+add_task(async function test_delete_buffering() {
   store.wipe();
-  yield PlacesTestUtils.markBookmarksAsSynced();
+  await PlacesTestUtils.markBookmarksAsSynced();
 
   try {
     _("Create a folder with two bookmarks.");
     let folder = new BookmarkFolder("bookmarks", "testfolder-1");
     folder.parentName = "Bookmarks Toolbar";
     folder.parentid = "toolbar";
     folder.title = "Test Folder";
     store.applyIncoming(folder);
@@ -505,17 +505,17 @@ add_task(function* test_delete_buffering
 
     equal(PlacesUtils.bookmarks.getFolderIdForItem(fxRecordId), folderId);
 
     ok(store._itemsToDelete.has(folder.id));
     ok(store._itemsToDelete.has(fxRecord.id));
     ok(!store._itemsToDelete.has(tbRecord.id));
 
     _("Process pending deletions and ensure that the right things are deleted.");
-    let newChangeRecords = yield store.deletePending();
+    let newChangeRecords = await store.deletePending();
 
     deepEqual(Object.keys(newChangeRecords).sort(), ["get-tndrbrd1", "toolbar"]);
 
     assertDeleted(fxRecordId);
     assertDeleted(folderId);
 
     ok(!store._itemsToDelete.has(folder.id));
     ok(!store._itemsToDelete.has(fxRecord.id));

--- a/services/sync/tests/unit/test_bookmark_tracker.js
+++ b/services/sync/tests/unit/test_bookmark_tracker.js
@@ -2,17 +2,17 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 Cu.import("resource://gre/modules/PlacesUtils.jsm");
 const {
   // `fetchGuidsWithAnno` isn't exported, but we can still access it here via a
   // backstage pass.
   fetchGuidsWithAnno,
 } = Cu.import("resource://gre/modules/PlacesSyncUtils.jsm");
-Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/PlacesSyncUtils.jsm");
 Cu.import("resource://services-sync/constants.js");
 Cu.import("resource://services-sync/engines/bookmarks.js");
 Cu.import("resource://services-sync/engines.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://gre/modules/osfile.jsm");
 Cu.import("resource://gre/modules/Task.jsm");
 Cu.import("resource://testing-common/PlacesTestUtils.jsm");
@@ -24,65 +24,65 @@ var store  = engine._store;
 var tracker = engine._tracker;
 
 store.wipe();
 tracker.persistChangedIDs = false;
 
 const DAY_IN_MS = 24 * 60 * 60 * 1000;
 
 // Test helpers.
-function* verifyTrackerEmpty() {
-  let changes = yield tracker.promiseChangedIDs();
+async function verifyTrackerEmpty() {
+  let changes = await tracker.promiseChangedIDs();
   deepEqual(changes, {});
   equal(tracker.score, 0);
 }
 
-function* resetTracker() {
-  yield PlacesTestUtils.markBookmarksAsSynced();
+async function resetTracker() {
+  await PlacesTestUtils.markBookmarksAsSynced();
   tracker.resetScore();
 }
 
-function* cleanup() {
+async function cleanup() {
   engine.lastSync = 0;
   store.wipe();
-  yield resetTracker();
-  yield stopTracking();
+  await resetTracker();
+  await stopTracking();
 }
 
 // startTracking is a signal that the test wants to notice things that happen
 // after this is called (ie, things already tracked should be discarded.)
-function* startTracking() {
+async function startTracking() {
   Svc.Obs.notify("weave:engine:start-tracking");
-  yield PlacesTestUtils.markBookmarksAsSynced();
+  await PlacesTestUtils.markBookmarksAsSynced();
 }
 
-function* stopTracking() {
+async function stopTracking() {
   Svc.Obs.notify("weave:engine:stop-tracking");
 }
 
-function* verifyTrackedItems(tracked) {
-  let changedIDs = yield tracker.promiseChangedIDs();
+async function verifyTrackedItems(tracked) {
+  let changedIDs = await tracker.promiseChangedIDs();
   let trackedIDs = new Set(Object.keys(changedIDs));
   for (let guid of tracked) {
     ok(guid in changedIDs, `${guid} should be tracked`);
     ok(changedIDs[guid].modified > 0, `${guid} should have a modified time`);
     ok(changedIDs[guid].counter >= -1, `${guid} should have a change counter`);
     trackedIDs.delete(guid);
   }
   equal(trackedIDs.size, 0, `Unhandled tracked IDs: ${
     JSON.stringify(Array.from(trackedIDs))}`);
 }
 
-function* verifyTrackedCount(expected) {
-  let changedIDs = yield tracker.promiseChangedIDs();
+async function verifyTrackedCount(expected) {
+  let changedIDs = await tracker.promiseChangedIDs();
   do_check_attribute_count(changedIDs, expected);
 }
 
 // A debugging helper that dumps the full bookmarks tree.
-function* dumpBookmarks() {
+async function dumpBookmarks() {
   let columns = ["id", "title", "guid", "syncStatus", "syncChangeCounter", "position"];
   return PlacesUtils.promiseDBConnection().then(connection => {
     let all = [];
     return connection.executeCached(`SELECT ${columns.join(", ")} FROM moz_bookmarks;`,
                                     {},
                                     row => {
                                       let repr = {};
                                       for (let column of columns) {
@@ -92,413 +92,413 @@ function* dumpBookmarks() {
                                     }
     ).then(() => {
       dump("All bookmarks:\n");
       dump(JSON.stringify(all, undefined, 2));
     });
   })
 }
 
-var populateTree = Task.async(function* populate(parentId, ...items) {
+var populateTree = async function populate(parentId, ...items) {
   let guids = {};
   for (let item of items) {
     let itemId;
     switch (item.type) {
       case PlacesUtils.bookmarks.TYPE_BOOKMARK:
         itemId = PlacesUtils.bookmarks.insertBookmark(parentId,
           Utils.makeURI(item.url),
           PlacesUtils.bookmarks.DEFAULT_INDEX, item.title);
         break;
 
       case PlacesUtils.bookmarks.TYPE_FOLDER: {
         itemId = PlacesUtils.bookmarks.createFolder(parentId,
           item.title, PlacesUtils.bookmarks.DEFAULT_INDEX);
-        Object.assign(guids, yield* populate(itemId, ...item.children));
+        Object.assign(guids, await populate(itemId, ...item.children));
         break;
       }
 
       default:
         throw new Error(`Unsupported item type: ${item.type}`);
     }
     if (item.exclude) {
       PlacesUtils.annotations.setItemAnnotation(
         itemId, BookmarkAnnos.EXCLUDEBACKUP_ANNO, "Don't back this up", 0,
         PlacesUtils.annotations.EXPIRE_NEVER);
     }
-    guids[item.title] = yield PlacesUtils.promiseItemGuid(itemId);
+    guids[item.title] = await PlacesUtils.promiseItemGuid(itemId);
   }
   return guids;
-});
+}
 
-function* insertBookmarksToMigrate() {
-  let mozBmk = yield PlacesUtils.bookmarks.insert({
+async function insertBookmarksToMigrate() {
+  let mozBmk = await PlacesUtils.bookmarks.insert({
     guid: "0gtWTOgYcoJD",
     parentGuid: PlacesUtils.bookmarks.menuGuid,
     url: "https://mozilla.org",
   });
-  let fxBmk = yield PlacesUtils.bookmarks.insert({
+  let fxBmk = await PlacesUtils.bookmarks.insert({
     guid: "0dbpnMdxKxfg",
     parentGuid: PlacesUtils.bookmarks.menuGuid,
     url: "http://getfirefox.com",
   });
-  let tbBmk = yield PlacesUtils.bookmarks.insert({
+  let tbBmk = await PlacesUtils.bookmarks.insert({
     guid: "r5ouWdPB3l28",
     parentGuid: PlacesUtils.bookmarks.menuGuid,
     url: "http://getthunderbird.com",
   });
-  let bzBmk = yield PlacesUtils.bookmarks.insert({
+  let bzBmk = await PlacesUtils.bookmarks.insert({
     guid: "YK5Bdq5MIqL6",
     parentGuid: PlacesUtils.bookmarks.menuGuid,
     url: "https://bugzilla.mozilla.org",
   });
-  let exampleBmk = yield PlacesUtils.bookmarks.insert({
+  let exampleBmk = await PlacesUtils.bookmarks.insert({
     parentGuid: PlacesUtils.bookmarks.menuGuid,
     url: "https://example.com",
   });
 
-  yield PlacesTestUtils.setBookmarkSyncFields({
+  await PlacesTestUtils.setBookmarkSyncFields({
     guid: fxBmk.guid,
     syncStatus: PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
   }, {
     guid: tbBmk.guid,
     syncStatus: PlacesUtils.bookmarks.SYNC_STATUS.UNKNOWN,
   }, {
     guid: exampleBmk.guid,
     syncStatus: PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
   });
 
-  yield PlacesUtils.bookmarks.remove(exampleBmk.guid);
+  await PlacesUtils.bookmarks.remove(exampleBmk.guid);
 }
 
-add_task(function* test_tracking() {
+add_task(async function test_tracking() {
   _("Test starting and stopping the tracker");
 
   // Remove existing tracking information for roots.
-  yield startTracking();
+  await startTracking();
 
   let folder = PlacesUtils.bookmarks.createFolder(
     PlacesUtils.bookmarks.bookmarksMenuFolder,
     "Test Folder", PlacesUtils.bookmarks.DEFAULT_INDEX);
 
   // creating the folder should have made 2 changes - the folder itself and
   // the parent of the folder.
-  yield verifyTrackedCount(2);
+  await verifyTrackedCount(2);
   // Reset the changes as the rest of the test doesn't want to see these.
-  yield resetTracker();
+  await resetTracker();
 
   function createBmk() {
     return PlacesUtils.bookmarks.insertBookmark(
       folder, Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
   }
 
   try {
     _("Tell the tracker to start tracking changes.");
-    yield startTracking();
+    await startTracking();
     createBmk();
     // We expect two changed items because the containing folder
     // changed as well (new child).
-    yield verifyTrackedCount(2);
+    await verifyTrackedCount(2);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
     _("Notifying twice won't do any harm.");
     createBmk();
-    yield verifyTrackedCount(3);
+    await verifyTrackedCount(3);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 2);
 
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_batch_tracking() {
+add_task(async function test_batch_tracking() {
   _("Test tracker does the correct thing during and after a places 'batch'");
 
-  yield startTracking();
+  await startTracking();
 
   PlacesUtils.bookmarks.runInBatchMode({
     runBatched: function() {
       let folder = PlacesUtils.bookmarks.createFolder(
         PlacesUtils.bookmarks.bookmarksMenuFolder,
         "Test Folder", PlacesUtils.bookmarks.DEFAULT_INDEX);
       // We should be tracking the new folder and its parent (and need to jump
       // through blocking hoops...)
-      Async.promiseSpinningly(Task.spawn(verifyTrackedCount(2)));
+      Async.promiseSpinningly(verifyTrackedCount(2));
       // But not have bumped the score.
       do_check_eq(tracker.score, 0);
     }
   }, null);
 
   // Out of batch mode - tracker should be the same, but score should be up.
-  yield verifyTrackedCount(2);
+  await verifyTrackedCount(2);
   do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-  yield cleanup();
+  await cleanup();
 });
 
-add_task(function* test_nested_batch_tracking() {
+add_task(async function test_nested_batch_tracking() {
   _("Test tracker does the correct thing if a places 'batch' is nested");
 
-  yield startTracking();
+  await startTracking();
 
   PlacesUtils.bookmarks.runInBatchMode({
     runBatched: function() {
 
       PlacesUtils.bookmarks.runInBatchMode({
         runBatched: function() {
           let folder = PlacesUtils.bookmarks.createFolder(
             PlacesUtils.bookmarks.bookmarksMenuFolder,
             "Test Folder", PlacesUtils.bookmarks.DEFAULT_INDEX);
           // We should be tracking the new folder and its parent (and need to jump
           // through blocking hoops...)
-          Async.promiseSpinningly(Task.spawn(verifyTrackedCount(2)));
+          Async.promiseSpinningly(verifyTrackedCount(2));
           // But not have bumped the score.
           do_check_eq(tracker.score, 0);
         }
       }, null);
       _("inner batch complete.");
       // should still not have a score as the outer batch is pending.
       do_check_eq(tracker.score, 0);
     }
   }, null);
 
   // Out of both batches - tracker should be the same, but score should be up.
-  yield verifyTrackedCount(2);
+  await verifyTrackedCount(2);
   do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-  yield cleanup();
+  await cleanup();
 });
 
-add_task(function* test_tracker_sql_batching() {
+add_task(async function test_tracker_sql_batching() {
   _("Test tracker does the correct thing when it is forced to batch SQL queries");
 
   const SQLITE_MAX_VARIABLE_NUMBER = 999;
   let numItems = SQLITE_MAX_VARIABLE_NUMBER * 2 + 10;
   let createdIDs = [];
 
-  yield startTracking();
+  await startTracking();
 
   PlacesUtils.bookmarks.runInBatchMode({
     runBatched: function() {
       for (let i = 0; i < numItems; i++) {
         let syncBmkID = PlacesUtils.bookmarks.insertBookmark(
                           PlacesUtils.bookmarks.unfiledBookmarksFolder,
                           Utils.makeURI("https://example.org/" + i),
                           PlacesUtils.bookmarks.DEFAULT_INDEX,
                           "Sync Bookmark " + i);
         createdIDs.push(syncBmkID);
       }
     }
   }, null);
 
   do_check_eq(createdIDs.length, numItems);
-  yield verifyTrackedCount(numItems + 1); // the folder is also tracked.
-  yield resetTracker();
+  await verifyTrackedCount(numItems + 1); // the folder is also tracked.
+  await resetTracker();
 
   PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.bookmarks.unfiledBookmarksFolder);
-  yield verifyTrackedCount(numItems + 1);
+  await verifyTrackedCount(numItems + 1);
 
-  yield cleanup();
+  await cleanup();
 });
 
-add_task(function* test_onItemAdded() {
+add_task(async function test_onItemAdded() {
   _("Items inserted via the synchronous bookmarks API should be tracked");
 
   try {
-    yield startTracking();
+    await startTracking();
 
     _("Insert a folder using the sync API");
     let syncFolderID = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder, "Sync Folder",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let syncFolderGUID = engine._store.GUIDForId(syncFolderID);
-    yield verifyTrackedItems(["menu", syncFolderGUID]);
+    await verifyTrackedItems(["menu", syncFolderGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
-    yield resetTracker();
-    yield startTracking();
+    await resetTracker();
+    await startTracking();
 
     _("Insert a bookmark using the sync API");
     let syncBmkID = PlacesUtils.bookmarks.insertBookmark(syncFolderID,
       Utils.makeURI("https://example.org/sync"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Sync Bookmark");
     let syncBmkGUID = engine._store.GUIDForId(syncBmkID);
-    yield verifyTrackedItems([syncFolderGUID, syncBmkGUID]);
+    await verifyTrackedItems([syncFolderGUID, syncBmkGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
-    yield resetTracker();
-    yield startTracking();
+    await resetTracker();
+    await startTracking();
 
     _("Insert a separator using the sync API");
     let syncSepID = PlacesUtils.bookmarks.insertSeparator(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       PlacesUtils.bookmarks.getItemIndex(syncFolderID));
     let syncSepGUID = engine._store.GUIDForId(syncSepID);
-    yield verifyTrackedItems(["menu", syncSepGUID]);
+    await verifyTrackedItems(["menu", syncSepGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemAdded() {
+add_task(async function test_async_onItemAdded() {
   _("Items inserted via the asynchronous bookmarks API should be tracked");
 
   try {
-    yield startTracking();
+    await startTracking();
 
     _("Insert a folder using the async API");
-    let asyncFolder = yield PlacesUtils.bookmarks.insert({
+    let asyncFolder = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       title: "Async Folder",
     });
-    yield verifyTrackedItems(["menu", asyncFolder.guid]);
+    await verifyTrackedItems(["menu", asyncFolder.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
-    yield resetTracker();
-    yield startTracking();
+    await resetTracker();
+    await startTracking();
 
     _("Insert a bookmark using the async API");
-    let asyncBmk = yield PlacesUtils.bookmarks.insert({
+    let asyncBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: asyncFolder.guid,
       url: "https://example.org/async",
       title: "Async Bookmark",
     });
-    yield verifyTrackedItems([asyncFolder.guid, asyncBmk.guid]);
+    await verifyTrackedItems([asyncFolder.guid, asyncBmk.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
-    yield resetTracker();
-    yield startTracking();
+    await resetTracker();
+    await startTracking();
 
     _("Insert a separator using the async API");
-    let asyncSep = yield PlacesUtils.bookmarks.insert({
+    let asyncSep = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_SEPARATOR,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       index: asyncFolder.index,
     });
-    yield verifyTrackedItems(["menu", asyncSep.guid]);
+    await verifyTrackedItems(["menu", asyncSep.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemChanged() {
+add_task(async function test_async_onItemChanged() {
   _("Items updated using the asynchronous bookmarks API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark");
-    let fxBmk = yield PlacesUtils.bookmarks.insert({
+    let fxBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
     _(`Firefox GUID: ${fxBmk.guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     _("Update the bookmark using the async API");
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: fxBmk.guid,
       title: "Download Firefox",
       url: "https://www.mozilla.org/firefox",
       // PlacesUtils.bookmarks.update rejects last modified dates older than
       // the added date.
       lastModified: new Date(Date.now() + DAY_IN_MS),
     });
 
-    yield verifyTrackedItems([fxBmk.guid]);
+    await verifyTrackedItems([fxBmk.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemChanged_itemDates() {
+add_task(async function test_onItemChanged_itemDates() {
   _("Changes to item dates should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark");
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
     let fx_guid = engine._store.GUIDForId(fx_id);
     _(`Firefox GUID: ${fx_guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     _("Reset the bookmark's added date");
     // Convert to microseconds for PRTime.
     let dateAdded = (Date.now() - DAY_IN_MS) * 1000;
     PlacesUtils.bookmarks.setItemDateAdded(fx_id, dateAdded);
-    yield verifyTrackedItems([fx_guid]);
+    await verifyTrackedItems([fx_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
+    await resetTracker();
 
     _("Set the bookmark's last modified date");
     let dateModified = Date.now() * 1000;
     PlacesUtils.bookmarks.setItemLastModified(fx_id, dateModified);
-    yield verifyTrackedItems([fx_guid]);
+    await verifyTrackedItems([fx_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemChanged_changeBookmarkURI() {
+add_task(async function test_onItemChanged_changeBookmarkURI() {
   _("Changes to bookmark URIs should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark");
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
     let fx_guid = engine._store.GUIDForId(fx_id);
     _(`Firefox GUID: ${fx_guid}`);
 
     _("Set a tracked annotation to make sure we only notify once");
     PlacesUtils.annotations.setItemAnnotation(
       fx_id, PlacesSyncUtils.bookmarks.DESCRIPTION_ANNO, "A test description", 0,
       PlacesUtils.annotations.EXPIRE_NEVER);
 
-    yield startTracking();
+    await startTracking();
 
     _("Change the bookmark's URI");
     PlacesUtils.bookmarks.changeBookmarkURI(fx_id,
       Utils.makeURI("https://www.mozilla.org/firefox"));
-    yield verifyTrackedItems([fx_guid]);
+    await verifyTrackedItems([fx_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemTagged() {
+add_task(async function test_onItemTagged() {
   _("Items tagged using the synchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Create a folder");
     let folder = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder, "Parent",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let folderGUID = engine._store.GUIDForId(folder);
     _("Folder ID: " + folder);
     _("Folder GUID: " + folderGUID);
@@ -507,340 +507,340 @@ add_task(function* test_onItemTagged() {
     let uri = Utils.makeURI("http://getfirefox.com");
     let b = PlacesUtils.bookmarks.insertBookmark(
       folder, uri,
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let bGUID = engine._store.GUIDForId(b);
     _("New item is " + b);
     _("GUID: " + bGUID);
 
-    yield startTracking();
+    await startTracking();
 
     _("Tag the item");
     PlacesUtils.tagging.tagURI(uri, ["foo"]);
 
     // bookmark should be tracked, folder should not be.
-    yield verifyTrackedItems([bGUID]);
+    await verifyTrackedItems([bGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemUntagged() {
+add_task(async function test_onItemUntagged() {
   _("Items untagged using the synchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert tagged bookmarks");
     let uri = Utils.makeURI("http://getfirefox.com");
     let fx1ID = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder, uri,
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let fx1GUID = engine._store.GUIDForId(fx1ID);
     // Different parent and title; same URL.
     let fx2ID = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.toolbarFolder, uri,
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Download Firefox");
     let fx2GUID = engine._store.GUIDForId(fx2ID);
     PlacesUtils.tagging.tagURI(uri, ["foo"]);
 
-    yield startTracking();
+    await startTracking();
 
     _("Remove the tag");
     PlacesUtils.tagging.untagURI(uri, ["foo"]);
 
-    yield verifyTrackedItems([fx1GUID, fx2GUID]);
+    await verifyTrackedItems([fx1GUID, fx2GUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 4);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemUntagged() {
+add_task(async function test_async_onItemUntagged() {
   _("Items untagged using the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert tagged bookmarks");
-    let fxBmk1 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk1 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let fxBmk2 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk2 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
       url: "http://getfirefox.com",
       title: "Download Firefox",
     });
-    let tag = yield PlacesUtils.bookmarks.insert({
+    let tag = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.tagsGuid,
       title: "some tag",
     });
-    let fxTag = yield PlacesUtils.bookmarks.insert({
+    let fxTag = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: tag.guid,
       url: "http://getfirefox.com",
     });
 
-    yield startTracking();
+    await startTracking();
 
     _("Remove the tag using the async bookmarks API");
-    yield PlacesUtils.bookmarks.remove(fxTag.guid);
+    await PlacesUtils.bookmarks.remove(fxTag.guid);
 
-    yield verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
+    await verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 4);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemTagged() {
+add_task(async function test_async_onItemTagged() {
   _("Items tagged using the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert untagged bookmarks");
-    let folder1 = yield PlacesUtils.bookmarks.insert({
+    let folder1 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       title: "Folder 1",
     });
-    let fxBmk1 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk1 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: folder1.guid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let folder2 = yield PlacesUtils.bookmarks.insert({
+    let folder2 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       title: "Folder 2",
     });
     // Different parent and title; same URL.
-    let fxBmk2 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk2 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: folder2.guid,
       url: "http://getfirefox.com",
       title: "Download Firefox",
     });
 
-    yield startTracking();
+    await startTracking();
 
     // This will change once tags are moved into a separate table (bug 424160).
     // We specifically test this case because Bookmarks.jsm updates tagged
     // bookmarks and notifies observers.
     _("Insert a tag using the async bookmarks API");
-    let tag = yield PlacesUtils.bookmarks.insert({
+    let tag = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.tagsGuid,
       title: "some tag",
     });
 
     _("Tag an item using the async bookmarks API");
-    yield PlacesUtils.bookmarks.insert({
+    await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: tag.guid,
       url: "http://getfirefox.com",
     });
 
-    yield verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
+    await verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 4);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemKeywordChanged() {
+add_task(async function test_onItemKeywordChanged() {
   _("Keyword changes via the synchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
     let folder = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder, "Parent",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let folderGUID = engine._store.GUIDForId(folder);
     _("Track changes to keywords");
     let uri = Utils.makeURI("http://getfirefox.com");
     let b = PlacesUtils.bookmarks.insertBookmark(
       folder, uri,
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let bGUID = engine._store.GUIDForId(b);
     _("New item is " + b);
     _("GUID: " + bGUID);
 
-    yield startTracking();
+    await startTracking();
 
     _("Give the item a keyword");
     PlacesUtils.bookmarks.setKeywordForBookmark(b, "the_keyword");
 
     // bookmark should be tracked, folder should not be.
-    yield verifyTrackedItems([bGUID]);
+    await verifyTrackedItems([bGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemKeywordChanged() {
+add_task(async function test_async_onItemKeywordChanged() {
   _("Keyword changes via the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert two bookmarks with the same URL");
-    let fxBmk1 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk1 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let fxBmk2 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk2 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
       url: "http://getfirefox.com",
       title: "Download Firefox",
     });
 
-    yield startTracking();
+    await startTracking();
 
     _("Add a keyword for both items");
-    yield PlacesUtils.keywords.insert({
+    await PlacesUtils.keywords.insert({
       keyword: "the_keyword",
       url: "http://getfirefox.com",
       postData: "postData",
     });
 
-    yield verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
+    await verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 2);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemKeywordDeleted() {
+add_task(async function test_async_onItemKeywordDeleted() {
   _("Keyword deletions via the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert two bookmarks with the same URL and keywords");
-    let fxBmk1 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk1 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let fxBmk2 = yield PlacesUtils.bookmarks.insert({
+    let fxBmk2 = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
       url: "http://getfirefox.com",
       title: "Download Firefox",
     });
-    yield PlacesUtils.keywords.insert({
+    await PlacesUtils.keywords.insert({
       keyword: "the_keyword",
       url: "http://getfirefox.com",
     });
 
-    yield startTracking();
+    await startTracking();
 
     _("Remove the keyword");
-    yield PlacesUtils.keywords.remove("the_keyword");
+    await PlacesUtils.keywords.remove("the_keyword");
 
-    yield verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
+    await verifyTrackedItems([fxBmk1.guid, fxBmk2.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 2);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemPostDataChanged() {
+add_task(async function test_onItemPostDataChanged() {
   _("Post data changes should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark");
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
     let fx_guid = engine._store.GUIDForId(fx_id);
     _(`Firefox GUID: ${fx_guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     // PlacesUtils.setPostDataForBookmark is deprecated, but still used by
     // PlacesTransactions.NewBookmark.
     _("Post data for the bookmark should be ignored");
-    yield PlacesUtils.setPostDataForBookmark(fx_id, "postData");
-    yield verifyTrackedItems([]);
+    await PlacesUtils.setPostDataForBookmark(fx_id, "postData");
+    await verifyTrackedItems([]);
     do_check_eq(tracker.score, 0);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemAnnoChanged() {
+add_task(async function test_onItemAnnoChanged() {
   _("Item annotations should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
     let folder = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder, "Parent",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let folderGUID = engine._store.GUIDForId(folder);
     _("Track changes to annos.");
     let b = PlacesUtils.bookmarks.insertBookmark(
       folder, Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let bGUID = engine._store.GUIDForId(b);
     _("New item is " + b);
     _("GUID: " + bGUID);
 
-    yield startTracking();
+    await startTracking();
     PlacesUtils.annotations.setItemAnnotation(
       b, PlacesSyncUtils.bookmarks.DESCRIPTION_ANNO, "A test description", 0,
       PlacesUtils.annotations.EXPIRE_NEVER);
     // bookmark should be tracked, folder should not.
-    yield verifyTrackedItems([bGUID]);
+    await verifyTrackedItems([bGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
+    await resetTracker();
 
     PlacesUtils.annotations.removeItemAnnotation(b,
       PlacesSyncUtils.bookmarks.DESCRIPTION_ANNO);
-    yield verifyTrackedItems([bGUID]);
+    await verifyTrackedItems([bGUID]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemAdded_filtered_root() {
+add_task(async function test_onItemAdded_filtered_root() {
   _("Items outside the change roots should not be tracked");
 
   try {
-    yield startTracking();
+    await startTracking();
 
     _("Create a new root");
     let rootID = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.placesRoot,
       "New root",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let rootGUID = engine._store.GUIDForId(rootID);
     _(`New root GUID: ${rootGUID}`);
@@ -858,180 +858,180 @@ add_task(function* test_onItemAdded_filt
     let rootBmkID = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.placesRoot,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let rootBmkGUID = engine._store.GUIDForId(rootBmkID);
     _(`New Places root bookmark GUID: ${rootBmkGUID}`);
 
     _("New root and bookmark should be ignored");
-    yield verifyTrackedItems([]);
+    await verifyTrackedItems([]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemDeleted_filtered_root() {
+add_task(async function test_onItemDeleted_filtered_root() {
   _("Deleted items outside the change roots should not be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark underneath the Places root");
     let rootBmkID = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.placesRoot,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX, "Get Firefox!");
     let rootBmkGUID = engine._store.GUIDForId(rootBmkID);
     _(`New Places root bookmark GUID: ${rootBmkGUID}`);
 
-    yield startTracking();
+    await startTracking();
 
     PlacesUtils.bookmarks.removeItem(rootBmkID);
 
-    yield verifyTrackedItems([]);
+    await verifyTrackedItems([]);
     // We'll still increment the counter for the removed item.
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onPageAnnoChanged() {
+add_task(async function test_onPageAnnoChanged() {
   _("Page annotations should not be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a bookmark without an annotation");
     let pageURI = Utils.makeURI("http://getfirefox.com");
     PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       pageURI,
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
 
-    yield startTracking();
+    await startTracking();
 
     _("Add a page annotation");
     PlacesUtils.annotations.setPageAnnotation(pageURI, "URIProperties/characterSet",
       "UTF-8", 0, PlacesUtils.annotations.EXPIRE_NEVER);
-    yield verifyTrackedItems([]);
+    await verifyTrackedItems([]);
     do_check_eq(tracker.score, 0);
-    yield resetTracker();
+    await resetTracker();
 
     _("Remove the page annotation");
     PlacesUtils.annotations.removePageAnnotation(pageURI,
       "URIProperties/characterSet");
-    yield verifyTrackedItems([]);
+    await verifyTrackedItems([]);
     do_check_eq(tracker.score, 0);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onFaviconChanged() {
+add_task(async function test_onFaviconChanged() {
   _("Favicon changes should not be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     let pageURI = Utils.makeURI("http://getfirefox.com");
     let iconURI = Utils.makeURI("http://getfirefox.com/icon");
     PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       pageURI,
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
 
-    yield PlacesTestUtils.addVisits(pageURI);
+    await PlacesTestUtils.addVisits(pageURI);
 
-    yield startTracking();
+    await startTracking();
 
     _("Favicon annotations should be ignored");
     let iconURL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAA" +
       "AAAA6fptVAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg==";
 
     PlacesUtils.favicons.replaceFaviconDataFromDataURL(iconURI, iconURL, 0,
       Services.scriptSecurityManager.getSystemPrincipal());
 
-    yield new Promise(resolve => {
+    await new Promise(resolve => {
       PlacesUtils.favicons.setAndFetchFaviconForPage(pageURI, iconURI, true,
         PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE, (iconURI, dataLen, data, mimeType) => {
           resolve();
         },
         Services.scriptSecurityManager.getSystemPrincipal());
     });
-    yield verifyTrackedItems([]);
+    await verifyTrackedItems([]);
     do_check_eq(tracker.score, 0);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onLivemarkAdded() {
+add_task(async function test_onLivemarkAdded() {
   _("New livemarks should be tracked");
 
   try {
-    yield startTracking();
+    await startTracking();
 
     _("Insert a livemark");
-    let livemark = yield PlacesUtils.livemarks.addLivemark({
+    let livemark = await PlacesUtils.livemarks.addLivemark({
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       // Use a local address just in case, to avoid potential aborts for
       // non-local connections.
       feedURI: Utils.makeURI("http://localhost:0"),
     });
     // Prevent the livemark refresh timer from requesting the URI.
     livemark.terminate();
 
-    yield verifyTrackedItems(["menu", livemark.guid]);
+    await verifyTrackedItems(["menu", livemark.guid]);
     // Two observer notifications: one for creating the livemark folder, and
     // one for setting the "livemark/feedURI" anno on the folder.
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 2);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onLivemarkDeleted() {
+add_task(async function test_onLivemarkDeleted() {
   _("Deleted livemarks should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert a livemark");
-    let livemark = yield PlacesUtils.livemarks.addLivemark({
+    let livemark = await PlacesUtils.livemarks.addLivemark({
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       feedURI: Utils.makeURI("http://localhost:0"),
     });
     livemark.terminate();
 
-    yield startTracking();
+    await startTracking();
 
     _("Remove a livemark");
-    yield PlacesUtils.livemarks.removeLivemark({
+    await PlacesUtils.livemarks.removeLivemark({
       guid: livemark.guid,
     });
 
-    yield verifyTrackedItems(["menu", livemark.guid]);
+    await verifyTrackedItems(["menu", livemark.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemMoved() {
+add_task(async function test_onItemMoved() {
   _("Items moved via the synchronous API should be tracked");
 
   try {
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
@@ -1040,136 +1040,136 @@ add_task(function* test_onItemMoved() {
     let tb_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getthunderbird.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Thunderbird!");
     let tb_guid = engine._store.GUIDForId(tb_id);
     _("Thunderbird GUID: " + tb_guid);
 
-    yield startTracking();
+    await startTracking();
 
     // Moving within the folder will just track the folder.
     PlacesUtils.bookmarks.moveItem(
       tb_id, PlacesUtils.bookmarks.bookmarksMenuFolder, 0);
-    yield verifyTrackedItems(['menu']);
+    await verifyTrackedItems(['menu']);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
-    yield PlacesTestUtils.markBookmarksAsSynced();
+    await resetTracker();
+    await PlacesTestUtils.markBookmarksAsSynced();
 
     // Moving a bookmark to a different folder will track the old
     // folder, the new folder and the bookmark.
     PlacesUtils.bookmarks.moveItem(fx_id, PlacesUtils.bookmarks.toolbarFolder,
                                    PlacesUtils.bookmarks.DEFAULT_INDEX);
-    yield verifyTrackedItems(['menu', 'toolbar', fx_guid]);
+    await verifyTrackedItems(['menu', 'toolbar', fx_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
 
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemMoved_update() {
+add_task(async function test_async_onItemMoved_update() {
   _("Items moved via the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
-    let fxBmk = yield PlacesUtils.bookmarks.insert({
+    let fxBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let tbBmk = yield PlacesUtils.bookmarks.insert({
+    let tbBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getthunderbird.com",
       title: "Get Thunderbird!",
     });
 
-    yield startTracking();
+    await startTracking();
 
     _("Repositioning a bookmark should track the folder");
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: tbBmk.guid,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       index: 0,
     });
-    yield verifyTrackedItems(['menu']);
+    await verifyTrackedItems(['menu']);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
+    await resetTracker();
 
     _("Reparenting a bookmark should track both folders and the bookmark");
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: tbBmk.guid,
       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
       index: PlacesUtils.bookmarks.DEFAULT_INDEX,
     });
-    yield verifyTrackedItems(['menu', 'toolbar', tbBmk.guid]);
+    await verifyTrackedItems(['menu', 'toolbar', tbBmk.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemMoved_reorder() {
+add_task(async function test_async_onItemMoved_reorder() {
   _("Items reordered via the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Insert out-of-order bookmarks");
-    let fxBmk = yield PlacesUtils.bookmarks.insert({
+    let fxBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
     _(`Firefox GUID: ${fxBmk.guid}`);
 
-    let tbBmk = yield PlacesUtils.bookmarks.insert({
+    let tbBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getthunderbird.com",
       title: "Get Thunderbird!",
     });
     _(`Thunderbird GUID: ${tbBmk.guid}`);
 
-    let mozBmk = yield PlacesUtils.bookmarks.insert({
+    let mozBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "https://mozilla.org",
       title: "Mozilla",
     });
     _(`Mozilla GUID: ${mozBmk.guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     _("Reorder bookmarks");
-    yield PlacesUtils.bookmarks.reorder(PlacesUtils.bookmarks.menuGuid,
+    await PlacesUtils.bookmarks.reorder(PlacesUtils.bookmarks.menuGuid,
       [mozBmk.guid, fxBmk.guid, tbBmk.guid]);
 
     // As with setItemIndex, we should only track the folder if we reorder
     // its children, but we should bump the score for every changed item.
-    yield verifyTrackedItems(["menu"]);
+    await verifyTrackedItems(["menu"]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemMoved_setItemIndex() {
+add_task(async function test_onItemMoved_setItemIndex() {
   _("Items with updated indices should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     let folder_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       "Test folder",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let folder_guid = engine._store.GUIDForId(folder_id);
     _(`Folder GUID: ${folder_guid}`);
 
@@ -1193,45 +1193,45 @@ add_task(function* test_onItemMoved_setI
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("https://mozilla.org"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Mozilla"
     );
     let moz_guid = engine._store.GUIDForId(moz_id);
     _(`Mozilla GUID: ${moz_guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     // PlacesSortFolderByNameTransaction exercises
     // PlacesUtils.bookmarks.setItemIndex.
     let txn = new PlacesSortFolderByNameTransaction(folder_id);
 
     // We're reordering items within the same folder, so only the folder
     // should be tracked.
     _("Execute the sort folder transaction");
     txn.doTransaction();
-    yield verifyTrackedItems([folder_guid]);
+    await verifyTrackedItems([folder_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
+    await resetTracker();
 
     _("Undo the sort folder transaction");
     txn.undoTransaction();
-    yield verifyTrackedItems([folder_guid]);
+    await verifyTrackedItems([folder_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemDeleted_removeFolderTransaction() {
+add_task(async function test_onItemDeleted_removeFolderTransaction() {
   _("Folders removed in a transaction should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
     _("Create a folder with two children");
     let folder_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       "Test folder",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
     let folder_guid = engine._store.GUIDForId(folder_id);
     _(`Folder GUID: ${folder_guid}`);
@@ -1245,49 +1245,49 @@ add_task(function* test_onItemDeleted_re
     let tb_id = PlacesUtils.bookmarks.insertBookmark(
       folder_id,
       Utils.makeURI("http://getthunderbird.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Thunderbird!");
     let tb_guid = engine._store.GUIDForId(tb_id);
     _(`Thunderbird GUID: ${tb_guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     let txn = PlacesUtils.bookmarks.getRemoveFolderTransaction(folder_id);
     // We haven't executed the transaction yet.
-    yield verifyTrackerEmpty();
+    await verifyTrackerEmpty();
 
     _("Execute the remove folder transaction");
     txn.doTransaction();
-    yield verifyTrackedItems(["menu", folder_guid, fx_guid, tb_guid]);
+    await verifyTrackedItems(["menu", folder_guid, fx_guid, tb_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
-    yield resetTracker();
+    await resetTracker();
 
     _("Undo the remove folder transaction");
     txn.undoTransaction();
 
     // At this point, the restored folder has the same ID, but a different GUID.
-    let new_folder_guid = yield PlacesUtils.promiseItemGuid(folder_id);
+    let new_folder_guid = await PlacesUtils.promiseItemGuid(folder_id);
 
-    yield verifyTrackedItems(["menu", new_folder_guid]);
+    await verifyTrackedItems(["menu", new_folder_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
-    yield resetTracker();
+    await resetTracker();
 
     _("Redo the transaction");
     txn.redoTransaction();
-    yield verifyTrackedItems(["menu", new_folder_guid]);
+    await verifyTrackedItems(["menu", new_folder_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_treeMoved() {
+add_task(async function test_treeMoved() {
   _("Moving an entire tree of bookmarks should track the parents");
 
   try {
     // Create a couple of parent folders.
     let folder1_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       "First test folder",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
@@ -1309,177 +1309,177 @@ add_task(function* test_treeMoved() {
     let fx_guid = engine._store.GUIDForId(fx_id);
     let tb_id = PlacesUtils.bookmarks.insertBookmark(
       folder2_id,
       Utils.makeURI("http://getthunderbird.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Thunderbird!");
     let tb_guid = engine._store.GUIDForId(tb_id);
 
-    yield startTracking();
+    await startTracking();
 
     // Move folder 2 to be a sibling of folder1.
     PlacesUtils.bookmarks.moveItem(
       folder2_id, PlacesUtils.bookmarks.bookmarksMenuFolder, 0);
     // the menu and both folders should be tracked, the children should not be.
-    yield verifyTrackedItems(['menu', folder1_guid, folder2_guid]);
+    await verifyTrackedItems(['menu', folder1_guid, folder2_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemDeleted() {
+add_task(async function test_onItemDeleted() {
   _("Bookmarks deleted via the synchronous API should be tracked");
 
   try {
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
     let fx_guid = engine._store.GUIDForId(fx_id);
     let tb_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("http://getthunderbird.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Thunderbird!");
     let tb_guid = engine._store.GUIDForId(tb_id);
 
-    yield startTracking();
+    await startTracking();
 
     // Delete the last item - the item and parent should be tracked.
     PlacesUtils.bookmarks.removeItem(tb_id);
 
-    yield verifyTrackedItems(['menu', tb_guid]);
+    await verifyTrackedItems(['menu', tb_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemDeleted() {
+add_task(async function test_async_onItemDeleted() {
   _("Bookmarks deleted via the asynchronous API should be tracked");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
-    let fxBmk = yield PlacesUtils.bookmarks.insert({
+    let fxBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
-    let tbBmk = yield PlacesUtils.bookmarks.insert({
+    let tbBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "http://getthunderbird.com",
       title: "Get Thunderbird!",
     });
 
-    yield startTracking();
+    await startTracking();
 
     _("Delete the first item");
-    yield PlacesUtils.bookmarks.remove(fxBmk.guid);
+    await PlacesUtils.bookmarks.remove(fxBmk.guid);
 
-    yield verifyTrackedItems(["menu", fxBmk.guid]);
+    await verifyTrackedItems(["menu", fxBmk.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_async_onItemDeleted_eraseEverything() {
+add_task(async function test_async_onItemDeleted_eraseEverything() {
   _("Erasing everything should track all deleted items");
 
   try {
-    yield stopTracking();
+    await stopTracking();
 
-    let fxBmk = yield PlacesUtils.bookmarks.insert({
+    let fxBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.mobileGuid,
       url: "http://getfirefox.com",
       title: "Get Firefox!",
     });
     _(`Firefox GUID: ${fxBmk.guid}`);
-    let tbBmk = yield PlacesUtils.bookmarks.insert({
+    let tbBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.mobileGuid,
       url: "http://getthunderbird.com",
       title: "Get Thunderbird!",
     });
     _(`Thunderbird GUID: ${tbBmk.guid}`);
-    let mozBmk = yield PlacesUtils.bookmarks.insert({
+    let mozBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "https://mozilla.org",
       title: "Mozilla",
     });
     _(`Mozilla GUID: ${mozBmk.guid}`);
-    let mdnBmk = yield PlacesUtils.bookmarks.insert({
+    let mdnBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: PlacesUtils.bookmarks.menuGuid,
       url: "https://developer.mozilla.org",
       title: "MDN",
     });
     _(`MDN GUID: ${mdnBmk.guid}`);
-    let bugsFolder = yield PlacesUtils.bookmarks.insert({
+    let bugsFolder = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: PlacesUtils.bookmarks.toolbarGuid,
       title: "Bugs",
     });
     _(`Bugs folder GUID: ${bugsFolder.guid}`);
-    let bzBmk = yield PlacesUtils.bookmarks.insert({
+    let bzBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: bugsFolder.guid,
       url: "https://bugzilla.mozilla.org",
       title: "Bugzilla",
     });
     _(`Bugzilla GUID: ${bzBmk.guid}`);
-    let bugsChildFolder = yield PlacesUtils.bookmarks.insert({
+    let bugsChildFolder = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_FOLDER,
       parentGuid: bugsFolder.guid,
       title: "Bugs child",
     });
     _(`Bugs child GUID: ${bugsChildFolder.guid}`);
-    let bugsGrandChildBmk = yield PlacesUtils.bookmarks.insert({
+    let bugsGrandChildBmk = await PlacesUtils.bookmarks.insert({
       type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
       parentGuid: bugsChildFolder.guid,
       url: "https://example.com",
       title: "Bugs grandchild",
     });
     _(`Bugs grandchild GUID: ${bugsGrandChildBmk.guid}`);
 
-    yield startTracking();
+    await startTracking();
     // Simulate moving a synced item into a new folder. Deleting the folder
     // should write a tombstone for the item, but not the folder.
-    yield PlacesTestUtils.setBookmarkSyncFields({
+    await PlacesTestUtils.setBookmarkSyncFields({
       guid: bugsChildFolder.guid,
       syncStatus: PlacesUtils.bookmarks.SYNC_STATUS.NEW,
     });
-    yield PlacesUtils.bookmarks.eraseEverything();
+    await PlacesUtils.bookmarks.eraseEverything();
 
     // bugsChildFolder's sync status is still "NEW", so it shouldn't be
     // tracked. bugsGrandChildBmk is "NORMAL", so we *should* write a
     // tombstone and track it.
-    yield verifyTrackedItems(["menu", mozBmk.guid, mdnBmk.guid, "toolbar",
+    await verifyTrackedItems(["menu", mozBmk.guid, mdnBmk.guid, "toolbar",
                               bugsFolder.guid, "mobile", fxBmk.guid,
                               tbBmk.guid, "unfiled", bzBmk.guid,
                               bugsGrandChildBmk.guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 8);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemDeleted_removeFolderChildren() {
+add_task(async function test_onItemDeleted_removeFolderChildren() {
   _("Removing a folder's children should track the folder and its children");
 
   try {
     let fx_id = PlacesUtils.bookmarks.insertBookmark(
       PlacesUtils.mobileFolderId,
       Utils.makeURI("http://getfirefox.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Firefox!");
@@ -1498,30 +1498,30 @@ add_task(function* test_onItemDeleted_re
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       Utils.makeURI("https://mozilla.org"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Mozilla"
     );
     let moz_guid = engine._store.GUIDForId(moz_id);
     _(`Mozilla GUID: ${moz_guid}`);
 
-    yield startTracking();
+    await startTracking();
 
     _(`Mobile root ID: ${PlacesUtils.mobileFolderId}`);
     PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.mobileFolderId);
 
-    yield verifyTrackedItems(["mobile", fx_guid, tb_guid]);
+    await verifyTrackedItems(["mobile", fx_guid, tb_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 2);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_onItemDeleted_tree() {
+add_task(async function test_onItemDeleted_tree() {
   _("Deleting a tree of bookmarks should track all items");
 
   try {
     // Create a couple of parent folders.
     let folder1_id = PlacesUtils.bookmarks.createFolder(
       PlacesUtils.bookmarks.bookmarksMenuFolder,
       "First test folder",
       PlacesUtils.bookmarks.DEFAULT_INDEX);
@@ -1543,266 +1543,266 @@ add_task(function* test_onItemDeleted_tr
     let fx_guid = engine._store.GUIDForId(fx_id);
     let tb_id = PlacesUtils.bookmarks.insertBookmark(
       folder2_id,
       Utils.makeURI("http://getthunderbird.com"),
       PlacesUtils.bookmarks.DEFAULT_INDEX,
       "Get Thunderbird!");
     let tb_guid = engine._store.GUIDForId(tb_id);
 
-    yield startTracking();
+    await startTracking();
 
     // Delete folder2 - everything we created should be tracked.
     PlacesUtils.bookmarks.removeItem(folder2_id);
 
-    yield verifyTrackedItems([fx_guid, tb_guid, folder1_guid, folder2_guid]);
+    await verifyTrackedItems([fx_guid, tb_guid, folder1_guid, folder2_guid]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 3);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_mobile_query() {
+add_task(async function test_mobile_query() {
   _("Ensure we correctly create the mobile query");
 
   try {
-    yield startTracking();
+    await startTracking();
 
     // Creates the organizer queries as a side effect.
     let leftPaneId = PlacesUIUtils.leftPaneFolderId;
     _(`Left pane root ID: ${leftPaneId}`);
 
-    let allBookmarksGuids = yield fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
+    let allBookmarksGuids = await fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
                                                      "AllBookmarks");
     equal(allBookmarksGuids.length, 1, "Should create folder with all bookmarks queries");
     let allBookmarkGuid = allBookmarksGuids[0];
 
     _("Try creating query after organizer is ready");
     tracker._ensureMobileQuery();
-    let queryGuids = yield fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
+    let queryGuids = await fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
                                               "MobileBookmarks");
     equal(queryGuids.length, 0, "Should not create query without any mobile bookmarks");
 
     _("Insert mobile bookmark, then create query");
-    let mozBmk = yield PlacesUtils.bookmarks.insert({
+    let mozBmk = await PlacesUtils.bookmarks.insert({
       parentGuid: PlacesUtils.bookmarks.mobileGuid,
       url: "https://mozilla.org",
     });
     tracker._ensureMobileQuery();
-    queryGuids = yield fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
+    queryGuids = await fetchGuidsWithAnno("PlacesOrganizer/OrganizerQuery",
                                           "MobileBookmarks");
     equal(queryGuids.length, 1, "Should create query once mobile bookmarks exist");
 
     let queryGuid = queryGuids[0];
 
-    let queryInfo = yield PlacesUtils.bookmarks.fetch(queryGuid);
+    let queryInfo = await PlacesUtils.bookmarks.fetch(queryGuid);
     equal(queryInfo.url, `place:folder=${PlacesUtils.mobileFolderId}`, "Query should point to mobile root");
     equal(queryInfo.title, "Mobile Bookmarks", "Query title should be localized");
     equal(queryInfo.parentGuid, allBookmarkGuid, "Should append mobile query to all bookmarks queries");
 
     _("Rename root and query, then recreate");
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: PlacesUtils.bookmarks.mobileGuid,
       title: "renamed root",
     });
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: queryGuid,
       title: "renamed query",
     });
     tracker._ensureMobileQuery();
-    let rootInfo = yield PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.mobileGuid);
+    let rootInfo = await PlacesUtils.bookmarks.fetch(PlacesUtils.bookmarks.mobileGuid);
     equal(rootInfo.title, "Mobile Bookmarks", "Should fix root title");
-    queryInfo = yield PlacesUtils.bookmarks.fetch(queryGuid);
+    queryInfo = await PlacesUtils.bookmarks.fetch(queryGuid);
     equal(queryInfo.title, "Mobile Bookmarks", "Should fix query title");
 
     _("Point query to different folder");
-    yield PlacesUtils.bookmarks.update({
+    await PlacesUtils.bookmarks.update({
       guid: queryGuid,
       url: "place:folder=BOOKMARKS_MENU",
     });
     tracker._ensureMobileQuery();
-    queryInfo = yield PlacesUtils.bookmarks.fetch(queryGuid);
+    queryInfo = await PlacesUtils.bookmarks.fetch(queryGuid);
     equal(queryInfo.url.href, `place:folder=${PlacesUtils.mobileFolderId}`,
       "Should fix query URL to point to mobile root");
 
     _("We shouldn't track the query or the left pane root");
-    yield verifyTrackedItems([mozBmk.guid, "mobile"]);
+    await verifyTrackedItems([mozBmk.guid, "mobile"]);
     do_check_eq(tracker.score, SCORE_INCREMENT_XLARGE * 5);
   } finally {
     _("Clean up.");
-    yield cleanup();
+    await cleanup();
   }
 });
 
-add_task(function* test_skip_migration() {
-  yield* insertBookmarksToMigrate();
+add_task(async function test_skip_migration() {
+  await insertBookmarksToMigrate();
 
-  let originalTombstones = yield PlacesTestUtils.fetchSyncTombstones();
-  let originalFields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+  let originalTombstones = await PlacesTestUtils.fetchSyncTombstones();
+  let originalFields = await PlacesTestUtils.fetchBookmarkSyncFields(
     "0gtWTOgYcoJD", "0dbpnMdxKxfg", "r5ouWdPB3l28", "YK5Bdq5MIqL6");
 
   let filePath = OS.Path.join(OS.Constants.Path.profileDir, "weave", "changes",
     "bookmarks.json");
 
   _("No tracker file");
   {
-    yield Utils.jsonRemove("changes/bookmarks", tracker);
-    ok(!(yield OS.File.exists(filePath)), "Tracker file should not exist");
+    await Utils.jsonRemove("changes/bookmarks", tracker);
+    ok(!(await OS.File.exists(filePath)), "Tracker file should not exist");
 
-    yield tracker._migrateOldEntries();
+    await tracker._migrateOldEntries();
 
-    let fields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+    let fields = await PlacesTestUtils.fetchBookmarkSyncFields(
       "0gtWTOgYcoJD", "0dbpnMdxKxfg", "r5ouWdPB3l28", "YK5Bdq5MIqL6");
     deepEqual(fields, originalFields,
       "Sync fields should not change if tracker file is missing");
-    let tombstones = yield PlacesTestUtils.fetchSyncTombstones();
+    let tombstones = await PlacesTestUtils.fetchSyncTombstones();
     deepEqual(tombstones, originalTombstones,
       "Tombstones should not change if tracker file is missing");
   }
 
   _("Existing tracker file; engine disabled");
   {
-    yield Utils.jsonSave("changes/bookmarks", tracker, {});
-    ok(yield OS.File.exists(filePath),
+    await Utils.jsonSave("changes/bookmarks", tracker, {});
+    ok(await OS.File.exists(filePath),
       "Tracker file should exist before disabled engine migration");
 
     engine.disabled = true;
-    yield tracker._migrateOldEntries();
+    await tracker._migrateOldEntries();
     engine.disabled = false;
 
-    let fields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+    let fields = await PlacesTestUtils.fetchBookmarkSyncFields(
       "0gtWTOgYcoJD", "0dbpnMdxKxfg", "r5ouWdPB3l28", "YK5Bdq5MIqL6");
     deepEqual(fields, originalFields,
       "Sync fields should not change on disabled engine migration");
-    let tombstones = yield PlacesTestUtils.fetchSyncTombstones();
+    let tombstones = await PlacesTestUtils.fetchSyncTombstones();
     deepEqual(tombstones, originalTombstones,
       "Tombstones should not change if tracker file is missing");
 
-    ok(!(yield OS.File.exists(filePath)),
+    ok(!(await OS.File.exists(filePath)),
       "Tracker file should be deleted after disabled engine migration");
   }
 
   _("Existing tracker file; first sync");
   {
-    yield Utils.jsonSave("changes/bookmarks", tracker, {});
-    ok(yield OS.File.exists(filePath),
+    await Utils.jsonSave("changes/bookmarks", tracker, {});
+    ok(await OS.File.exists(filePath),
       "Tracker file should exist before first sync migration");
 
     engine.lastSync = 0;
-    yield tracker._migrateOldEntries();
+    await tracker._migrateOldEntries();
 
-    let fields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+    let fields = await PlacesTestUtils.fetchBookmarkSyncFields(
       "0gtWTOgYcoJD", "0dbpnMdxKxfg", "r5ouWdPB3l28", "YK5Bdq5MIqL6");
     deepEqual(fields, originalFields,
       "Sync fields should not change on first sync migration");
-    let tombstones = yield PlacesTestUtils.fetchSyncTombstones();
+    let tombstones = await PlacesTestUtils.fetchSyncTombstones();
     deepEqual(tombstones, originalTombstones,
       "Tombstones should not change if tracker file is missing");
 
-    ok(!(yield OS.File.exists(filePath)),
+    ok(!(await OS.File.exists(filePath)),
       "Tracker file should be deleted after first sync migration");
   }
 
-  yield* cleanup();
+  await cleanup();
 });
 
-add_task(function* test_migrate_empty_tracker() {
+add_task(async function test_migrate_empty_tracker() {
   _("Migration with empty tracker file");
-  yield* insertBookmarksToMigrate();
+  await insertBookmarksToMigrate();
 
-  yield Utils.jsonSave("changes/bookmarks", tracker, {});
+  await Utils.jsonSave("changes/bookmarks", tracker, {});
 
   engine.lastSync = Date.now() / 1000;
-  yield tracker._migrateOldEntries();
+  await tracker._migrateOldEntries();
 
-  let fields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+  let fields = await PlacesTestUtils.fetchBookmarkSyncFields(
     "0gtWTOgYcoJD", "0dbpnMdxKxfg", "r5ouWdPB3l28", "YK5Bdq5MIqL6");
   for (let field of fields) {
     equal(field.syncStatus, PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
       `Sync status of migrated bookmark ${field.guid} should be NORMAL`);
     strictEqual(field.syncChangeCounter, 0,
       `Change counter of migrated bookmark ${field.guid} should be 0`);
   }
 
-  let tombstones = yield PlacesTestUtils.fetchSyncTombstones();
+  let tombstones = await PlacesTestUtils.fetchSyncTombstones();
   deepEqual(tombstones, [], "Migration should delete old tombstones");
 
   let filePath = OS.Path.join(OS.Constants.Path.profileDir, "weave", "changes",
     "bookmarks.json");
-  ok(!(yield OS.File.exists(filePath)),
+  ok(!(await OS.File.exists(filePath)),
     "Tracker file should be deleted after empty tracker migration");
 
-  yield* cleanup();
+  await cleanup();
 });
 
-add_task(function* test_migrate_existing_tracker() {
+add_task(async function test_migrate_existing_tracker() {
   _("Migration with existing tracker entries");
-  yield* insertBookmarksToMigrate();
+  await insertBookmarksToMigrate();
 
-  let mozBmk = yield PlacesUtils.bookmarks.fetch("0gtWTOgYcoJD");
-  let fxBmk = yield PlacesUtils.bookmarks.fetch("0dbpnMdxKxfg");
+  let mozBmk = await PlacesUtils.bookmarks.fetch("0gtWTOgYcoJD");
+  let fxBmk = await PlacesUtils.bookmarks.fetch("0dbpnMdxKxfg");
   let mozChangeTime = Math.floor(mozBmk.lastModified / 1000) - 60;
   let fxChangeTime = Math.floor(fxBmk.lastModified / 1000) + 60;
-  yield Utils.jsonSave("changes/bookmarks", tracker, {
+  await Utils.jsonSave("changes/bookmarks", tracker, {
     "0gtWTOgYcoJD": mozChangeTime,
     "0dbpnMdxKxfg": {
       modified: fxChangeTime,
       deleted: false,
     },
     "3kdIPWHs9hHC": {
       modified: 1479494951,
       deleted: true,
     },
     "l7DlMy2lL1jL": 1479496460,
   });
 
   engine.lastSync = Date.now() / 1000;
-  yield tracker._migrateOldEntries();
+  await tracker._migrateOldEntries();
 
-  let changedFields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+  let changedFields = await PlacesTestUtils.fetchBookmarkSyncFields(
     "0gtWTOgYcoJD", "0dbpnMdxKxfg");
   for (let field of changedFields) {
     if (field.guid == "0gtWTOgYcoJD") {
       ok(field.lastModified.getTime(), mozBmk.lastModified.getTime(),
         `Modified time for ${field.guid} should not be reset to older change time`);
     } else if (field.guid == "0dbpnMdxKxfg") {
       equal(field.lastModified.getTime(), fxChangeTime * 1000,
         `Modified time for ${field.guid} should be updated to newer change time`);
     }
     equal(field.syncStatus, PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
       `Sync status of migrated bookmark ${field.guid} should be NORMAL`);
     ok(field.syncChangeCounter > 0,
       `Change counter of migrated bookmark ${field.guid} should be > 0`);
   }
 
-  let unchangedFields = yield PlacesTestUtils.fetchBookmarkSyncFields(
+  let unchangedFields = await PlacesTestUtils.fetchBookmarkSyncFields(
     "r5ouWdPB3l28", "YK5Bdq5MIqL6");
   for (let field of unchangedFields) {
     equal(field.syncStatus, PlacesUtils.bookmarks.SYNC_STATUS.NORMAL,
       `Sync status of unchanged bookmark ${field.guid} should be NORMAL`);
     strictEqual(field.syncChangeCounter, 0,
       `Change counter of unchanged bookmark ${field.guid} should be 0`);
   }
 
-  let tombstones = yield PlacesTestUtils.fetchSyncTombstones();
-  yield deepEqual(tombstones, [{
+  let tombstones = await PlacesTestUtils.fetchSyncTombstones();
+  await deepEqual(tombstones, [{
     guid: "3kdIPWHs9hHC",
     dateRemoved: new Date(1479494951 * 1000),
   }, {
     guid: "l7DlMy2lL1jL",
     dateRemoved: new Date(1479496460 * 1000),
   }], "Should write tombstones for deleted tracked items");
 
   let filePath = OS.Path.join(OS.Constants.Path.profileDir, "weave", "changes",
     "bookmarks.json");
-  ok(!(yield OS.File.exists(filePath)),
+  ok(!(await OS.File.exists(filePath)),
     "Tracker file should be deleted after existing tracker migration");
 
-  yield* cleanup();
+  await cleanup();
 });
 
 function run_test() {
   initTestLogging("Trace");
 
   Log.repository.getLogger("Sync.Engine.Bookmarks").level = Log.Level.Trace;
   Log.repository.getLogger("Sync.Store.Bookmarks").level = Log.Level.Trace;
   Log.repository.getLogger("Sync.Tracker.Bookmarks").level = Log.Level.Trace;

--- a/services/sync/tests/unit/test_bookmark_validator.js
+++ b/services/sync/tests/unit/test_bookmark_validator.js
@@ -313,23 +313,23 @@ function validationPing(server, client, 
       recordCount: server.length,
       problems: validator.compareServerWithClient(server, client).problemData,
     };
     Svc.Obs.notify("weave:engine:validate:finish", data, "bookmarks");
     Svc.Obs.notify("weave:service:sync:finish");
   }, true); // Allow "failing" pings, since having validation info indicates failure.
 }
 
-add_task(function *test_telemetry_integration() {
+add_task(async function test_telemetry_integration() {
   let {server, client} = getDummyServerAndClient();
   // remove "c"
   server.pop();
   server[0].children.pop();
   const duration = 50;
-  let ping = yield validationPing(server, client, duration);
+  let ping = await validationPing(server, client, duration);
   ok(ping.engines);
   let bme = ping.engines.find(e => e.name === "bookmarks");
   ok(bme);
   ok(bme.validation);
   ok(bme.validation.problems)
   equal(bme.validation.checked, server.length);
   equal(bme.validation.took, duration);
   bme.validation.problems.sort((a, b) => String.localeCompare(a.name, b.name));

--- a/services/sync/tests/unit/test_browserid_identity.js
+++ b/services/sync/tests/unit/test_browserid_identity.js
@@ -72,27 +72,27 @@ function run_test() {
 add_test(function test_initial_state() {
     _("Verify initial state");
     do_check_false(!!browseridManager._token);
     do_check_false(browseridManager.hasValidToken());
     run_next_test();
   }
 );
 
-add_task(function* test_initialializeWithCurrentIdentity() {
+add_task(async function test_initialializeWithCurrentIdentity() {
     _("Verify start after initializeWithCurrentIdentity");
     browseridManager.initializeWithCurrentIdentity();
-    yield browseridManager.whenReadyToAuthenticate.promise;
+    await browseridManager.whenReadyToAuthenticate.promise;
     do_check_true(!!browseridManager._token);
     do_check_true(browseridManager.hasValidToken());
     do_check_eq(browseridManager.account, identityConfig.fxaccount.user.email);
   }
 );
 
-add_task(function* test_initialializeWithAuthErrorAndDeletedAccount() {
+add_task(async function test_initialializeWithAuthErrorAndDeletedAccount() {
     _("Verify sync unpair after initializeWithCurrentIdentity with auth error + account deleted");
 
     var identityConfig = makeIdentityConfig();
     var browseridManager = new BrowserIDManager();
 
     // Use the real `_getAssertion` method that calls
     // `mockFxAClient.signCertificate`.
     let fxaInternal = makeFxAccountsInternalMock(identityConfig);
@@ -120,38 +120,38 @@ add_task(function* test_initialializeWit
         accountStatusCalled = true;
         return Promise.resolve(false);
       }
     };
 
     let mockFxAClient = new MockFxAccountsClient();
     browseridManager._fxaService.internal._fxAccountsClient = mockFxAClient;
 
-    yield browseridManager.initializeWithCurrentIdentity();
-    yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+    await browseridManager.initializeWithCurrentIdentity();
+    await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                      "should reject due to an auth error");
 
     do_check_true(signCertificateCalled);
     do_check_true(accountStatusCalled);
     do_check_false(browseridManager.account);
     do_check_false(browseridManager._token);
     do_check_false(browseridManager.hasValidToken());
     do_check_false(browseridManager.account);
 });
 
-add_task(function* test_initialializeWithNoKeys() {
+add_task(async function test_initialializeWithNoKeys() {
     _("Verify start after initializeWithCurrentIdentity without kA, kB or keyFetchToken");
     let identityConfig = makeIdentityConfig();
     delete identityConfig.fxaccount.user.kA;
     delete identityConfig.fxaccount.user.kB;
     // there's no keyFetchToken by default, so the initialize should fail.
     configureFxAccountIdentity(browseridManager, identityConfig);
 
-    yield browseridManager.initializeWithCurrentIdentity();
-    yield browseridManager.whenReadyToAuthenticate.promise;
+    await browseridManager.initializeWithCurrentIdentity();
+    await browseridManager.whenReadyToAuthenticate.promise;
     do_check_eq(Status.login, LOGIN_SUCCEEDED, "login succeeded even without keys");
     do_check_false(browseridManager._canFetchKeys(), "_canFetchKeys reflects lack of keys");
     do_check_eq(browseridManager._token, null, "we don't have a token");
 });
 
 add_test(function test_getResourceAuthenticator() {
     _("BrowserIDManager supplies a Resource Authenticator callback which returns a Hawk header.");
     configureFxAccountIdentity(browseridManager);
@@ -301,46 +301,46 @@ add_test(function test_RESTResourceAuthe
   // window.
   do_check_eq(getTimestamp(authHeader), now - 12 * HOUR_MS);
   do_check_true(
       (getTimestampDelta(authHeader, now) - 12 * HOUR_MS) < 2 * MINUTE_MS);
 
   run_next_test();
 });
 
-add_task(function* test_ensureLoggedIn() {
+add_task(async function test_ensureLoggedIn() {
   configureFxAccountIdentity(browseridManager);
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield browseridManager.whenReadyToAuthenticate.promise;
+  await browseridManager.initializeWithCurrentIdentity();
+  await browseridManager.whenReadyToAuthenticate.promise;
   Assert.equal(Status.login, LOGIN_SUCCEEDED, "original initialize worked");
-  yield browseridManager.ensureLoggedIn();
+  await browseridManager.ensureLoggedIn();
   Assert.equal(Status.login, LOGIN_SUCCEEDED, "original ensureLoggedIn worked");
   Assert.ok(browseridManager._shouldHaveSyncKeyBundle,
             "_shouldHaveSyncKeyBundle should always be true after ensureLogin completes.");
 
   // arrange for no logged in user.
   let fxa = browseridManager._fxaService
   let signedInUser = fxa.internal.currentAccountState.storageManager.accountData;
   fxa.internal.currentAccountState.storageManager.accountData = null;
   browseridManager.initializeWithCurrentIdentity();
   Assert.ok(!browseridManager._shouldHaveSyncKeyBundle,
             "_shouldHaveSyncKeyBundle should be false so we know we are testing what we think we are.");
   Status.login = LOGIN_FAILED_NO_USERNAME;
-  yield Assert.rejects(browseridManager.ensureLoggedIn(), "expecting rejection due to no user");
+  await Assert.rejects(browseridManager.ensureLoggedIn(), "expecting rejection due to no user");
   Assert.ok(browseridManager._shouldHaveSyncKeyBundle,
             "_shouldHaveSyncKeyBundle should always be true after ensureLogin completes.");
   // Restore the logged in user to what it was.
   fxa.internal.currentAccountState.storageManager.accountData = signedInUser;
   Status.login = LOGIN_FAILED_LOGIN_REJECTED;
-  yield Assert.rejects(browseridManager.ensureLoggedIn(),
+  await Assert.rejects(browseridManager.ensureLoggedIn(),
                        "LOGIN_FAILED_LOGIN_REJECTED should have caused immediate rejection");
   Assert.equal(Status.login, LOGIN_FAILED_LOGIN_REJECTED,
                "status should remain LOGIN_FAILED_LOGIN_REJECTED");
   Status.login = LOGIN_FAILED_NETWORK_ERROR;
-  yield browseridManager.ensureLoggedIn();
+  await browseridManager.ensureLoggedIn();
   Assert.equal(Status.login, LOGIN_SUCCEEDED, "final ensureLoggedIn worked");
 });
 
 add_test(function test_tokenExpiration() {
     _("BrowserIDManager notices token expiration:");
     let bimExp = new BrowserIDManager();
     configureFxAccountIdentity(bimExp, identityConfig);
 
@@ -399,50 +399,50 @@ add_test(function test_computeXClientSta
 
   let bidUser = new BrowserIDManager();
   let header = bidUser._computeXClientState(kB);
 
   do_check_eq(header, "6ae94683571c7a7c54dab4700aa3995f");
   run_next_test();
 });
 
-add_task(function* test_getTokenErrors() {
+add_task(async function test_getTokenErrors() {
   _("BrowserIDManager correctly handles various failures to get a token.");
 
   _("Arrange for a 401 - Sync should reflect an auth error.");
   initializeIdentityWithTokenServerResponse({
     status: 401,
     headers: {"content-type": "application/json"},
     body: JSON.stringify({}),
   });
   let browseridManager = Service.identity;
 
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await browseridManager.initializeWithCurrentIdentity();
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to 401");
   Assert.equal(Status.login, LOGIN_FAILED_LOGIN_REJECTED, "login was rejected");
 
   // XXX - other interesting responses to return?
 
   // And for good measure, some totally "unexpected" errors - we generally
   // assume these problems are going to magically go away at some point.
   _("Arrange for an empty body with a 200 response - should reflect a network error.");
   initializeIdentityWithTokenServerResponse({
     status: 200,
     headers: [],
     body: "",
   });
   browseridManager = Service.identity;
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await browseridManager.initializeWithCurrentIdentity();
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to non-JSON response");
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "login state is LOGIN_FAILED_NETWORK_ERROR");
 });
 
-add_task(function* test_refreshCertificateOn401() {
+add_task(async function test_refreshCertificateOn401() {
   _("BrowserIDManager refreshes the FXA certificate after a 401.");
   var identityConfig = makeIdentityConfig();
   var browseridManager = new BrowserIDManager();
   // Use the real `_getAssertion` method that calls
   // `mockFxAClient.signCertificate`.
   let fxaInternal = makeFxAccountsInternalMock(identityConfig);
   delete fxaInternal._getAssertion;
   configureFxAccountIdentity(browseridManager, identityConfig, fxaInternal);
@@ -486,47 +486,47 @@ add_task(function* test_refreshCertifica
           duration:     300,
         })
       };
     }
   });
 
   browseridManager._tokenServerClient = mockTSC;
 
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield browseridManager.whenReadyToAuthenticate.promise;
+  await browseridManager.initializeWithCurrentIdentity();
+  await browseridManager.whenReadyToAuthenticate.promise;
 
   do_check_eq(getCertCount, 2);
   do_check_true(didReturn401);
   do_check_true(didReturn200);
   do_check_true(browseridManager.account);
   do_check_true(browseridManager._token);
   do_check_true(browseridManager.hasValidToken());
   do_check_true(browseridManager.account);
 });
 
 
 
-add_task(function* test_getTokenErrorWithRetry() {
+add_task(async function test_getTokenErrorWithRetry() {
   _("tokenserver sends an observer notification on various backoff headers.");
 
   // Set Sync's backoffInterval to zero - after we simulated the backoff header
   // it should reflect the value we sent.
   Status.backoffInterval = 0;
   _("Arrange for a 503 with a Retry-After header.");
   initializeIdentityWithTokenServerResponse({
     status: 503,
     headers: {"content-type": "application/json",
               "retry-after": "100"},
     body: JSON.stringify({}),
   });
   let browseridManager = Service.identity;
 
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await browseridManager.initializeWithCurrentIdentity();
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to 503");
 
   // The observer should have fired - check it got the value in the response.
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "login was rejected");
   // Sync will have the value in ms with some slop - so check it is at least that.
   Assert.ok(Status.backoffInterval >= 100000);
 
   _("Arrange for a 200 with an X-Backoff header.");
@@ -534,168 +534,168 @@ add_task(function* test_getTokenErrorWit
   initializeIdentityWithTokenServerResponse({
     status: 503,
     headers: {"content-type": "application/json",
               "x-backoff": "200"},
     body: JSON.stringify({}),
   });
   browseridManager = Service.identity;
 
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await browseridManager.initializeWithCurrentIdentity();
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to no token in response");
 
   // The observer should have fired - check it got the value in the response.
   Assert.ok(Status.backoffInterval >= 200000);
 });
 
-add_task(function* test_getKeysErrorWithBackoff() {
+add_task(async function test_getKeysErrorWithBackoff() {
   _("Auth server (via hawk) sends an observer notification on backoff headers.");
 
   // Set Sync's backoffInterval to zero - after we simulated the backoff header
   // it should reflect the value we sent.
   Status.backoffInterval = 0;
   _("Arrange for a 503 with a X-Backoff header.");
 
   let config = makeIdentityConfig();
   // We want no kA or kB so we attempt to fetch them.
   delete config.fxaccount.user.kA;
   delete config.fxaccount.user.kB;
   config.fxaccount.user.keyFetchToken = "keyfetchtoken";
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "get");
     Assert.equal(uri, "http://mockedserver:9999/account/keys")
     return {
       status: 503,
       headers: {"content-type": "application/json",
                 "x-backoff": "100"},
       body: "{}",
     }
   });
 
   let browseridManager = Service.identity;
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to 503");
 
   // The observer should have fired - check it got the value in the response.
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "login was rejected");
   // Sync will have the value in ms with some slop - so check it is at least that.
   Assert.ok(Status.backoffInterval >= 100000);
 });
 
-add_task(function* test_getKeysErrorWithRetry() {
+add_task(async function test_getKeysErrorWithRetry() {
   _("Auth server (via hawk) sends an observer notification on retry headers.");
 
   // Set Sync's backoffInterval to zero - after we simulated the backoff header
   // it should reflect the value we sent.
   Status.backoffInterval = 0;
   _("Arrange for a 503 with a Retry-After header.");
 
   let config = makeIdentityConfig();
   // We want no kA or kB so we attempt to fetch them.
   delete config.fxaccount.user.kA;
   delete config.fxaccount.user.kB;
   config.fxaccount.user.keyFetchToken = "keyfetchtoken";
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "get");
     Assert.equal(uri, "http://mockedserver:9999/account/keys")
     return {
       status: 503,
       headers: {"content-type": "application/json",
                 "retry-after": "100"},
       body: "{}",
     }
   });
 
   let browseridManager = Service.identity;
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "should reject due to 503");
 
   // The observer should have fired - check it got the value in the response.
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "login was rejected");
   // Sync will have the value in ms with some slop - so check it is at least that.
   Assert.ok(Status.backoffInterval >= 100000);
 });
 
-add_task(function* test_getHAWKErrors() {
+add_task(async function test_getHAWKErrors() {
   _("BrowserIDManager correctly handles various HAWK failures.");
 
   _("Arrange for a 401 - Sync should reflect an auth error.");
   let config = makeIdentityConfig();
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "post");
     Assert.equal(uri, "http://mockedserver:9999/certificate/sign")
     return {
       status: 401,
       headers: {"content-type": "application/json"},
       body: JSON.stringify({}),
     }
   });
   Assert.equal(Status.login, LOGIN_FAILED_LOGIN_REJECTED, "login was rejected");
 
   // XXX - other interesting responses to return?
 
   // And for good measure, some totally "unexpected" errors - we generally
   // assume these problems are going to magically go away at some point.
   _("Arrange for an empty body with a 200 response - should reflect a network error.");
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "post");
     Assert.equal(uri, "http://mockedserver:9999/certificate/sign")
     return {
       status: 200,
       headers: [],
       body: "",
     }
   });
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "login state is LOGIN_FAILED_NETWORK_ERROR");
 });
 
-add_task(function* test_getGetKeysFailing401() {
+add_task(async function test_getGetKeysFailing401() {
   _("BrowserIDManager correctly handles 401 responses fetching keys.");
 
   _("Arrange for a 401 - Sync should reflect an auth error.");
   let config = makeIdentityConfig();
   // We want no kA or kB so we attempt to fetch them.
   delete config.fxaccount.user.kA;
   delete config.fxaccount.user.kB;
   config.fxaccount.user.keyFetchToken = "keyfetchtoken";
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "get");
     Assert.equal(uri, "http://mockedserver:9999/account/keys")
     return {
       status: 401,
       headers: {"content-type": "application/json"},
       body: "{}",
     }
   });
   Assert.equal(Status.login, LOGIN_FAILED_LOGIN_REJECTED, "login was rejected");
 });
 
-add_task(function* test_getGetKeysFailing503() {
+add_task(async function test_getGetKeysFailing503() {
   _("BrowserIDManager correctly handles 5XX responses fetching keys.");
 
   _("Arrange for a 503 - Sync should reflect a network error.");
   let config = makeIdentityConfig();
   // We want no kA or kB so we attempt to fetch them.
   delete config.fxaccount.user.kA;
   delete config.fxaccount.user.kB;
   config.fxaccount.user.keyFetchToken = "keyfetchtoken";
-  yield initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
+  await initializeIdentityWithHAWKResponseFactory(config, function(method, data, uri) {
     Assert.equal(method, "get");
     Assert.equal(uri, "http://mockedserver:9999/account/keys")
     return {
       status: 503,
       headers: {"content-type": "application/json"},
       body: "{}",
     }
   });
   Assert.equal(Status.login, LOGIN_FAILED_NETWORK_ERROR, "state reflects network error");
 });
 
-add_task(function* test_getKeysMissing() {
+add_task(async function test_getKeysMissing() {
   _("BrowserIDManager correctly handles getKeys succeeding but not returning keys.");
 
   let browseridManager = new BrowserIDManager();
   let identityConfig = makeIdentityConfig();
   // our mock identity config already has kA and kB - remove them or we never
   // try and fetch them.
   delete identityConfig.fxaccount.user.kA;
   delete identityConfig.fxaccount.user.kB;
@@ -727,29 +727,29 @@ add_task(function* test_getKeysMissing()
       validUntil: fxa.internal.now() + CERT_LIFETIME,
       cert: "certificate",
     };
     return Promise.resolve(this.cert.cert);
   };
 
   browseridManager._fxaService = fxa;
 
-  yield browseridManager.initializeWithCurrentIdentity();
+  await browseridManager.initializeWithCurrentIdentity();
 
   let ex;
   try {
-    yield browseridManager.whenReadyToAuthenticate.promise;
+    await browseridManager.whenReadyToAuthenticate.promise;
   } catch (e) {
     ex = e;
   }
 
   Assert.ok(ex.message.indexOf("missing kA or kB") >= 0);
 });
 
-add_task(function* test_signedInUserMissing() {
+add_task(async function test_signedInUserMissing() {
   _("BrowserIDManager detects getSignedInUser returning incomplete account data");
 
   let browseridManager = new BrowserIDManager();
   let config = makeIdentityConfig();
   // Delete stored keys and the key fetch token.
   delete identityConfig.fxaccount.user.kA;
   delete identityConfig.fxaccount.user.kB;
   delete identityConfig.fxaccount.user.keyFetchToken;
@@ -770,31 +770,31 @@ add_task(function* test_signedInUserMiss
       let storageManager = new MockFxaStorageManager();
       storageManager.initialize(identityConfig.fxaccount.user);
       return new AccountState(storageManager);
     },
   });
 
   browseridManager._fxaService = fxa;
 
-  let status = yield browseridManager.unlockAndVerifyAuthState();
+  let status = await browseridManager.unlockAndVerifyAuthState();
   Assert.equal(status, LOGIN_FAILED_LOGIN_REJECTED);
 });
 
 // End of tests
 // Utility functions follow
 
 // Create a new browserid_identity object and initialize it with a
 // hawk mock that simulates HTTP responses.
 // The callback function will be called each time the mocked hawk server wants
 // to make a request.  The result of the callback should be the mock response
 // object that will be returned to hawk.
 // A token server mock will be used that doesn't hit a server, so we move
 // directly to a hawk request.
-function* initializeIdentityWithHAWKResponseFactory(config, cbGetResponse) {
+async function initializeIdentityWithHAWKResponseFactory(config, cbGetResponse) {
   // A mock request object.
   function MockRESTRequest(uri, credentials, extra) {
     this._uri = uri;
     this._credentials = credentials;
     this._extra = extra;
   };
   MockRESTRequest.prototype = {
     setHeader: function() {},
@@ -843,18 +843,18 @@ function* initializeIdentityWithHAWKResp
       storageManager.initialize(config.fxaccount.user);
       return new AccountState(storageManager);
     },
   }
   let fxa = new FxAccounts(internal);
 
   browseridManager._fxaService = fxa;
   browseridManager._signedInUser = null;
-  yield browseridManager.initializeWithCurrentIdentity();
-  yield Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
+  await browseridManager.initializeWithCurrentIdentity();
+  await Assert.rejects(browseridManager.whenReadyToAuthenticate.promise,
                        "expecting rejection due to hawk error");
 }
 
 
 function getTimestamp(hawkAuthHeader) {
   return parseInt(/ts="(\d+)"/.exec(hawkAuthHeader)[1], 10) * SECOND_MS;
 }