--- a/services/sync/modules-testing/utils.js
+++ b/services/sync/modules-testing/utils.js
@@ -10,17 +10,16 @@ this.EXPORTED_SYMBOLS = [
   "makeIdentityConfig",
   "makeFxAccountsInternalMock",
   "configureFxAccountIdentity",
   "configureIdentity",
   "SyncTestingInfrastructure",
   "waitForZeroTimer",
   "promiseZeroTimer",
   "promiseNamedTimer",
-  "add_identity_test",
   "MockFxaStorageManager",
   "AccountState", // from a module import
   "sumHistogram",
 ];
 
 var {utils: Cu} = Components;
 
 Cu.import("resource://services-sync/status.js");
@@ -256,42 +255,16 @@ this.encryptPayload = function encryptPa
 
   return {
     ciphertext: cleartext, // ciphertext == cleartext with fake crypto
     IV: "irrelevant",
     hmac: fakeSHA256HMAC(cleartext, CryptoUtils.makeHMACKey("")),
   };
 }
 
-// This helper can be used instead of 'add_test' or 'add_task' to run the
-// specified test function with different identity managers.
-// So far we use this with one, the FxA one, but we keep it in case we change
-// idmanagers again.
-//
-// * The test itself should be passed as 'test' - ie, test code will generally
-//   pass |this|.
-// * The test function is a regular test function - although note that it must
-//   be a generator - async operations should yield them, and run_next_test
-//   mustn't be called.
-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);
-  test.add_task(async function() {
-    note("FxAccounts");
-    let oldIdentity = Status._authManager;
-    Status.__authManager = ns.Service.identity = new BrowserIDManager();
-    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);
   let sum = -Infinity;
   if (snapshot) {
     sum = snapshot.sum;
   }

--- a/services/sync/tests/unit/test_collections_recovery.js
+++ b/services/sync/tests/unit/test_collections_recovery.js
@@ -1,17 +1,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 // Verify that we wipe the server if we have to regenerate keys.
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/util.js");
 Cu.import("resource://testing-common/services/sync/utils.js");
 
-add_identity_test(this, async function test_missing_crypto_collection() {
+add_task(async function test_missing_crypto_collection() {
   let johnHelper = track_collections_helper();
   let johnU      = johnHelper.with_updated_collection;
   let johnColls  = johnHelper.collections;
 
   let empty = false;
   function maybe_empty(handler) {
     return function(request, response) {
       if (empty) {

--- a/services/sync/tests/unit/test_errorhandler_1.js
+++ b/services/sync/tests/unit/test_errorhandler_1.js
@@ -58,17 +58,17 @@ function run_test() {
 
 function clean() {
   Service.startOver();
   Status.resetSync();
   Status.resetBackoff();
   errorHandler.didReportProlongedError = false;
 }
 
-add_identity_test(this, async function test_401_logout() {
+add_task(async function test_401_logout() {
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   await sync_and_validate_telem();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
 
@@ -101,17 +101,17 @@ add_identity_test(this, async function t
 
   _("Starting first sync.");
   let ping = await sync_and_validate_telem(true);
   deepEqual(ping.failureReason, { name: "httperror", code: 401 });
   _("First sync done.");
   await deferred.promise;
 });
 
-add_identity_test(this, async function test_credentials_changed_logout() {
+add_task(async function test_credentials_changed_logout() {
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   await sync_and_validate_telem();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
   do_check_true(Service.isLoggedIn);
 
@@ -127,32 +127,32 @@ add_identity_test(this, async function t
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   do_check_false(Service.isLoggedIn);
 
   // Clean up.
   Service.startOver();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, function test_no_lastSync_pref() {
+add_task(function test_no_lastSync_pref() {
   // Test reported error.
   Status.resetSync();
   errorHandler.dontIgnoreErrors = true;
   Status.sync = CREDENTIALS_CHANGED;
   do_check_true(errorHandler.shouldReportError());
 
   // Test unreported error.
   Status.resetSync();
   errorHandler.dontIgnoreErrors = true;
   Status.login = LOGIN_FAILED_NETWORK_ERROR;
   do_check_true(errorHandler.shouldReportError());
 
 });
 
-add_identity_test(this, function test_shouldReportError() {
+add_task(function test_shouldReportError() {
   Status.login = MASTER_PASSWORD_LOCKED;
   do_check_false(errorHandler.shouldReportError());
 
   // Give ourselves a clusterURL so that the temporary 401 no-error situation
   // doesn't come into play.
   Service.serverURL  = fakeServerUrl;
   Service.clusterURL = fakeServerUrl;
 
@@ -315,17 +315,17 @@ add_identity_test(this, function test_sh
   Status.resetSync();
   setLastSync(PROLONGED_ERROR_DURATION);
   errorHandler.dontIgnoreErrors = true;
   Status.login = SERVER_MAINTENANCE;
   do_check_true(errorHandler.shouldReportError());
   do_check_false(errorHandler.didReportProlongedError);
 });
 
-add_identity_test(this, async function test_shouldReportError_master_password() {
+add_task(async function test_shouldReportError_master_password() {
   _("Test error ignored due to locked master password");
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // Monkey patch Service.verifyLogin to imitate
   // master password being locked.
   Service._verifyLogin = Service.verifyLogin;
   Service.verifyLogin = function() {
@@ -340,17 +340,17 @@ add_identity_test(this, async function t
   // Clean up.
   Service.verifyLogin = Service._verifyLogin;
   clean();
   await promiseStopServer(server);
 });
 
 // Test that even if we don't have a cluster URL, a login failure due to
 // authentication errors is always reported.
-add_identity_test(this, function test_shouldReportLoginFailureWithNoCluster() {
+add_task(function test_shouldReportLoginFailureWithNoCluster() {
   // Ensure no clusterURL - any error not specific to login should not be reported.
   Service.serverURL  = "";
   Service.clusterURL = "";
 
   // Test explicit "login rejected" state.
   Status.resetSync();
   // If we have a LOGIN_REJECTED state, we always report the error.
   Status.login = LOGIN_FAILED_LOGIN_REJECTED;
@@ -374,17 +374,17 @@ add_task(async function test_login_syncA
   errorHandler.syncAndReportErrors();
   await promiseObserved;
   do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_sync_syncAndReportErrors_non_network_error() {
+add_task(async function test_sync_syncAndReportErrors_non_network_error() {
   // Test non-network errors are reported
   // when calling syncAndReportErrors
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
@@ -423,17 +423,17 @@ add_task(async function test_login_syncA
   errorHandler.syncAndReportErrors();
   await promiseObserved;
   do_check_eq(Status.login, LOGIN_FAILED_NO_PASSPHRASE);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_sync_syncAndReportErrors_prolonged_non_network_error() {
+add_task(async function test_sync_syncAndReportErrors_prolonged_non_network_error() {
   // Test prolonged, non-network errors are
   // reported when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   // By calling sync, we ensure we're logged in.
   Service.sync();
   do_check_eq(Status.sync, SYNC_SUCCEEDED);
@@ -454,17 +454,17 @@ add_identity_test(this, async function t
 
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   // If we clean this tick, telemetry won't get the right error
   await promiseNextTick();
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_login_syncAndReportErrors_network_error() {
+add_task(async function test_login_syncAndReportErrors_network_error() {
   // Test network errors are reported when calling syncAndReportErrors.
   await configureIdentity({username: "broken.wipe"});
   Service.serverURL  = fakeServerUrl;
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
@@ -489,17 +489,17 @@ add_test(function test_sync_syncAndRepor
     clean();
     run_next_test();
   });
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   errorHandler.syncAndReportErrors();
 });
 
-add_identity_test(this, async function test_login_syncAndReportErrors_prolonged_network_error() {
+add_task(async function test_login_syncAndReportErrors_prolonged_network_error() {
   // Test prolonged, network errors are reported
   // when calling syncAndReportErrors.
   await configureIdentity({username: "johndoe"});
 
   Service.serverURL  = fakeServerUrl;
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
@@ -572,17 +572,17 @@ add_task(async function test_sync_prolon
   });
   await promiseObserved;
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_login_prolonged_network_error() {
+add_task(async function test_login_prolonged_network_error() {
   // Test prolonged, network errors are reported
   await configureIdentity({username: "johndoe"});
   Service.serverURL  = fakeServerUrl;
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:login:error");
 
   setLastSync(PROLONGED_ERROR_DURATION);
@@ -649,17 +649,17 @@ add_task(async function test_sync_non_ne
   await promiseObserved;
   do_check_eq(Status.sync, CREDENTIALS_CHANGED);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_login_network_error() {
+add_task(async function test_login_network_error() {
   await configureIdentity({username: "johndoe"});
   Service.serverURL  = fakeServerUrl;
   Service.clusterURL = fakeServerUrl;
 
   let promiseObserved = promiseOneObserver("weave:ui:clear-error");
   // Test network errors are not reported.
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
@@ -685,17 +685,17 @@ add_test(function test_sync_network_erro
     clean();
     run_next_test();
   });
 
   setLastSync(NON_PROLONGED_ERROR_DURATION);
   Service.sync();
 });
 
-add_identity_test(this, async function test_sync_server_maintenance_error() {
+add_task(async function test_sync_server_maintenance_error() {
   // Test server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 503,
@@ -719,17 +719,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
   do_check_eq(Status.sync, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_info_collections_login_server_maintenance_error() {
+add_task(async function test_info_collections_login_server_maintenance_error() {
   // Test info/collections server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -757,17 +757,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   Svc.Obs.remove("weave:ui:login:error", onUIUpdate);
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_meta_global_login_server_maintenance_error() {
+add_task(async function test_meta_global_login_server_maintenance_error() {
   // Test meta/global server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {

--- a/services/sync/tests/unit/test_errorhandler_2.js
+++ b/services/sync/tests/unit/test_errorhandler_2.js
@@ -58,17 +58,17 @@ function run_test() {
 
 function clean() {
   Service.startOver();
   Status.resetSync();
   Status.resetBackoff();
   errorHandler.didReportProlongedError = false;
 }
 
-add_identity_test(this, async function test_crypto_keys_login_server_maintenance_error() {
+add_task(async function test_crypto_keys_login_server_maintenance_error() {
   Status.resetSync();
   // Test crypto/keys server maintenance errors are not reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
 
   // Force re-download of keys
@@ -130,17 +130,17 @@ add_task(async function test_sync_prolon
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   await promiseStopServer(server);
   clean();
 });
 
-add_identity_test(this, async function test_info_collections_login_prolonged_server_maintenance_error() {
+add_task(async function test_info_collections_login_prolonged_server_maintenance_error() {
   // Test info/collections prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -162,17 +162,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_meta_global_login_prolonged_server_maintenance_error() {
+add_task(async function test_meta_global_login_prolonged_server_maintenance_error() {
   // Test meta/global prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -194,17 +194,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_download_crypto_keys_login_prolonged_server_maintenance_error() {
+add_task(async function test_download_crypto_keys_login_prolonged_server_maintenance_error() {
   // Test crypto/keys prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
 
@@ -227,17 +227,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_upload_crypto_keys_login_prolonged_server_maintenance_error() {
+add_task(async function test_upload_crypto_keys_login_prolonged_server_maintenance_error() {
   // Test crypto/keys prolonged server maintenance errors are reported.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
   Svc.Obs.add("weave:service:backoff:interval", function observe(subject, data) {
@@ -259,17 +259,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_wipeServer_login_prolonged_server_maintenance_error() {
+add_task(async function test_wipeServer_login_prolonged_server_maintenance_error() {
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping the server.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;
@@ -292,17 +292,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, SYNC_FAILED);
   do_check_eq(Status.sync, PROLONGED_SYNC_FAILURE);
   do_check_true(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_wipeRemote_prolonged_server_maintenance_error() {
+add_task(async function test_wipeRemote_prolonged_server_maintenance_error() {
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping all remote devices.
   let server = EHTestsCommon.sync_httpd_setup();
 
   server.registerPathHandler("/1.1/broken.wipe/storage/catapult", EHTestsCommon.service_unavailable);
   await configureIdentity({username: "broken.wipe"}, server);
   EHTestsCommon.generateAndUploadKeys();
 
@@ -360,17 +360,17 @@ add_task(async function test_sync_syncAn
   do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
   do_check_eq(Status.sync, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_info_collections_login_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_info_collections_login_syncAndReportErrors_server_maintenance_error() {
   // Test info/collections server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
@@ -393,17 +393,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, LOGIN_FAILED);
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_meta_global_login_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_meta_global_login_syncAndReportErrors_server_maintenance_error() {
   // Test meta/global server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
@@ -426,17 +426,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, LOGIN_FAILED);
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_download_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_download_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
@@ -461,17 +461,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, LOGIN_FAILED);
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_upload_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
@@ -494,17 +494,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, LOGIN_FAILED);
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_wipeServer_login_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_wipeServer_login_syncAndReportErrors_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;
@@ -527,17 +527,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.service, LOGIN_FAILED);
   do_check_eq(Status.login, SERVER_MAINTENANCE);
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_wipeRemote_syncAndReportErrors_server_maintenance_error() {
+add_task(async function test_wipeRemote_syncAndReportErrors_server_maintenance_error() {
   // Test that we report prolonged server maintenance errors that occur whilst
   // wiping all remote devices.
   let server = EHTestsCommon.sync_httpd_setup();
 
   await configureIdentity({username: "broken.wipe"}, server);
   EHTestsCommon.generateAndUploadKeys();
 
   let engine = engineManager.get("catapult");
@@ -596,17 +596,17 @@ add_task(async function test_sync_syncAn
   // syncAndReportErrors means dontIgnoreErrors, which means
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_info_collections_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+add_task(async function test_info_collections_login_syncAndReportErrors_prolonged_server_maintenance_error() {
   // Test info/collections server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.info"}, server);
 
   let backoffInterval;
@@ -631,17 +631,17 @@ add_identity_test(this, async function t
   // syncAndReportErrors means dontIgnoreErrors, which means
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_meta_global_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+add_task(async function test_meta_global_login_syncAndReportErrors_prolonged_server_maintenance_error() {
   // Test meta/global server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.meta"}, server);
 
   let backoffInterval;
@@ -666,17 +666,17 @@ add_identity_test(this, async function t
   // syncAndReportErrors means dontIgnoreErrors, which means
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_download_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+add_task(async function test_download_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
   await EHTestsCommon.setUp(server);
 
   await configureIdentity({username: "broken.keys"}, server);
   // Force re-download of keys
   Service.collectionKeys.clear();
@@ -703,17 +703,17 @@ add_identity_test(this, async function t
   // syncAndReportErrors means dontIgnoreErrors, which means
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_upload_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+add_task(async function test_upload_crypto_keys_login_syncAndReportErrors_prolonged_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.keys"}, server);
 
   let backoffInterval;
@@ -738,17 +738,17 @@ add_identity_test(this, async function t
   // syncAndReportErrors means dontIgnoreErrors, which means
   // didReportProlongedError not touched.
   do_check_false(errorHandler.didReportProlongedError);
 
   clean();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_wipeServer_login_syncAndReportErrors_prolonged_server_maintenance_error() {
+add_task(async function test_wipeServer_login_syncAndReportErrors_prolonged_server_maintenance_error() {
   // Test crypto/keys server maintenance errors are reported
   // when calling syncAndReportErrors.
   let server = EHTestsCommon.sync_httpd_setup();
 
   // Start off with an empty account, do not upload a key.
   await configureIdentity({username: "broken.wipe"}, server);
 
   let backoffInterval;

--- a/services/sync/tests/unit/test_errorhandler_eol.js
+++ b/services/sync/tests/unit/test_errorhandler_eol.js
@@ -59,17 +59,17 @@ function do_check_soft_eol(eh, start) {
 }
 function do_check_hard_eol(eh, start) {
   // We subtract 1000 because the stored value is in second precision.
   do_check_true(eh.earliestNextAlert >= (start + eh.MINIMUM_ALERT_INTERVAL_MSEC - 1000));
   do_check_eq("hard-eol", eh.currentAlertMode);
   do_check_true(Status.eol);
 }
 
-add_identity_test(this, async function test_200_hard() {
+add_task(async function test_200_hard() {
   let eh = Service.errorHandler;
   let start = Date.now();
   let server = sync_httpd_setup(handler200("hard-eol"));
   await setUp(server);
 
   let promiseObserved = promiseOneObserver("weave:eol");
 
   Service._fetchInfo();
@@ -78,17 +78,17 @@ add_identity_test(this, async function t
   let { subject } = await promiseObserved;
   do_check_eq("hard-eol", subject.code);
   do_check_hard_eol(eh, start);
   do_check_eq(Service.scheduler.eolInterval, Service.scheduler.syncInterval);
   eh.clearServerAlerts();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_513_hard() {
+add_task(async function test_513_hard() {
   let eh = Service.errorHandler;
   let start = Date.now();
   let server = sync_httpd_setup(handler513);
   await setUp(server);
 
   let promiseObserved = promiseOneObserver("weave:eol");
 
   try {
@@ -101,17 +101,17 @@ add_identity_test(this, async function t
   do_check_eq("hard-eol", subject.code);
   do_check_hard_eol(eh, start);
   do_check_eq(Service.scheduler.eolInterval, Service.scheduler.syncInterval);
   eh.clearServerAlerts();
 
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_200_soft() {
+add_task(async function test_200_soft() {
   let eh = Service.errorHandler;
   let start = Date.now();
   let server = sync_httpd_setup(handler200("soft-eol"));
   await setUp(server);
 
   let promiseObserved = promiseOneObserver("weave:eol");
 
   Service._fetchInfo();

--- a/services/sync/tests/unit/test_errorhandler_sync_checkServerError.js
+++ b/services/sync/tests/unit/test_errorhandler_sync_checkServerError.js
@@ -61,17 +61,17 @@ function generateAndUploadKeys(server) {
   generateNewKeys(Service.collectionKeys);
   let serverKeys = Service.collectionKeys.asWBO("crypto", "keys");
   serverKeys.encrypt(Service.identity.syncKeyBundle);
   let res = Service.resource(server.baseURI + "/1.1/johndoe/storage/crypto/keys");
   return serverKeys.upload(res).success;
 }
 
 
-add_identity_test(this, async function test_backoff500() {
+add_task(async function test_backoff500() {
   _("Test: HTTP 500 sets backoff status.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 500};
 
@@ -88,17 +88,17 @@ add_identity_test(this, async function t
     do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
   } finally {
     Status.resetBackoff();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_backoff503() {
+add_task(async function test_backoff503() {
   _("Test: HTTP 503 with Retry-After header leads to backoff notification and sets backoff status.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   const BACKOFF = 42;
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 503,
@@ -124,17 +124,17 @@ add_identity_test(this, async function t
   } finally {
     Status.resetBackoff();
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_overQuota() {
+add_task(async function test_overQuota() {
   _("Test: HTTP 400 with body error code 14 means over quota.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 400,
                       toString() {
@@ -153,17 +153,17 @@ add_identity_test(this, async function t
     do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
   } finally {
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_service_networkError() {
+add_task(async function test_service_networkError() {
   _("Test: Connection refused error from Service.sync() leads to the right status code.");
   let server = sync_httpd_setup();
   await setUp(server);
   await promiseStopServer(server);
   // Provoke connection refused.
   Service.clusterURL = "http://localhost:12345/";
 
   try {
@@ -175,17 +175,17 @@ add_identity_test(this, async function t
     do_check_eq(Status.sync, LOGIN_FAILED_NETWORK_ERROR);
     do_check_eq(Status.service, SYNC_FAILED);
   } finally {
     Status.resetSync();
     Service.startOver();
   }
 });
 
-add_identity_test(this, async function test_service_offline() {
+add_task(async function test_service_offline() {
   _("Test: Wanting to sync in offline mode leads to the right status code but does not increment the ignorable error count.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   await promiseStopServer(server);
   Services.io.offline = true;
   Services.prefs.setBoolPref("network.dns.offline-localhost", false);
 
@@ -200,17 +200,17 @@ add_identity_test(this, async function t
   } finally {
     Status.resetSync();
     Service.startOver();
   }
   Services.io.offline = false;
   Services.prefs.clearUserPref("network.dns.offline-localhost");
 });
 
-add_identity_test(this, async function test_engine_networkError() {
+add_task(async function test_engine_networkError() {
   _("Test: Network related exceptions from engine.sync() lead to the right status code.");
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = Components.Exception("NS_ERROR_UNKNOWN_HOST",
                                           Cr.NS_ERROR_UNKNOWN_HOST);
@@ -227,17 +227,17 @@ add_identity_test(this, async function t
     do_check_eq(Status.service, SYNC_FAILED_PARTIAL);
   } finally {
     Status.resetSync();
     Service.startOver();
   }
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_resource_timeout() {
+add_task(async function test_resource_timeout() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   let engine = engineManager.get("catapult");
   engine.enabled = true;
   // Resource throws this when it encounters a timeout.
   engine.exception = Components.Exception("Aborting due to channel inactivity.",
                                           Cr.NS_ERROR_NET_TIMEOUT);

--- a/services/sync/tests/unit/test_interval_triggers.js
+++ b/services/sync/tests/unit/test_interval_triggers.js
@@ -52,17 +52,17 @@ function run_test() {
   initTestLogging("Trace");
 
   Log.repository.getLogger("Sync.Service").level = Log.Level.Trace;
   Log.repository.getLogger("Sync.SyncScheduler").level = Log.Level.Trace;
 
   run_next_test();
 }
 
-add_identity_test(this, async function test_successful_sync_adjustSyncInterval() {
+add_task(async function test_successful_sync_adjustSyncInterval() {
   _("Test successful sync calling adjustSyncInterval");
   let syncSuccesses = 0;
   function onSyncFinish() {
     _("Sync success.");
     syncSuccesses++;
   }
   Svc.Obs.add("weave:service:sync:finish", onSyncFinish);
 
@@ -151,17 +151,17 @@ add_identity_test(this, async function t
   do_check_false(scheduler.hasIncomingItems); // gets reset to false
   do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
 
   Svc.Obs.remove("weave:service:sync:finish", onSyncFinish);
   Service.startOver();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_unsuccessful_sync_adjustSyncInterval() {
+add_task(async function test_unsuccessful_sync_adjustSyncInterval() {
   _("Test unsuccessful sync calling adjustSyncInterval");
 
   let syncFailures = 0;
   function onSyncError() {
     _("Sync error.");
     syncFailures++;
   }
   Svc.Obs.add("weave:service:sync:error", onSyncError);
@@ -256,17 +256,17 @@ add_identity_test(this, async function t
   do_check_false(scheduler.hasIncomingItems); // gets reset to false
   do_check_eq(scheduler.syncInterval, scheduler.immediateInterval);
 
   Service.startOver();
   Svc.Obs.remove("weave:service:sync:error", onSyncError);
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_back_triggers_sync() {
+add_task(async function test_back_triggers_sync() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Single device: no sync triggered.
   scheduler.idle = true;
   scheduler.observe(null, "active", Svc.Prefs.get("scheduler.idleTime"));
   do_check_false(scheduler.idle);
 
@@ -285,17 +285,17 @@ add_identity_test(this, async function t
   Svc.Prefs.resetBranch("");
   scheduler.setDefaults();
   clientsEngine.resetClient();
 
   Service.startOver();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_adjust_interval_on_sync_error() {
+add_task(async function test_adjust_interval_on_sync_error() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   let syncFailures = 0;
   function onSyncError() {
     _("Sync error.");
     syncFailures++;
   }
@@ -316,17 +316,17 @@ add_identity_test(this, async function t
   do_check_true(scheduler.numClients > 1);
   do_check_eq(scheduler.syncInterval, scheduler.activeInterval);
 
   Svc.Obs.remove("weave:service:sync:error", onSyncError);
   Service.startOver();
   await promiseStopServer(server);
 });
 
-add_identity_test(this, async function test_bug671378_scenario() {
+add_task(async function test_bug671378_scenario() {
   // Test scenario similar to bug 671378. This bug appeared when a score
   // update occurred that wasn't large enough to trigger a sync so
   // scheduleNextSync() was called without a time interval parameter,
   // setting nextSync to a non-zero value and preventing the timer from
   // being adjusted in the next call to scheduleNextSync().
   let server = sync_httpd_setup();
   await setUp(server);
 

--- a/services/sync/tests/unit/test_service_startOver.js
+++ b/services/sync/tests/unit/test_service_startOver.js
@@ -23,17 +23,17 @@ BlaEngine.prototype = {
 Service.engineManager.register(BlaEngine);
 
 
 function run_test() {
   initTestLogging("Trace");
   run_next_test();
 }
 
-add_identity_test(this, async function test_resetLocalData() {
+add_task(async function test_resetLocalData() {
   await configureIdentity();
   Service.status.enforceBackoff = true;
   Service.status.backoffInterval = 42;
   Service.status.minimumNextSync = 23;
 
   // Verify set up.
   do_check_eq(Service.status.checkSetup(), STATUS_OK);
 

--- a/services/sync/tests/unit/test_service_wipeServer.js
+++ b/services/sync/tests/unit/test_service_wipeServer.js
@@ -39,17 +39,17 @@ async function setUpTestFixtures(server)
 }
 
 
 function run_test() {
   initTestLogging("Trace");
   run_next_test();
 }
 
-add_identity_test(this, async function test_wipeServer_list_success() {
+add_task(async function test_wipeServer_list_success() {
   _("Service.wipeServer() deletes collections given as argument.");
 
   let steam_coll = new FakeCollection();
   let diesel_coll = new FakeCollection();
 
   let server = httpd_setup({
     "/1.1/johndoe/storage/steam": steam_coll.handler(),
     "/1.1/johndoe/storage/diesel": diesel_coll.handler(),
@@ -73,17 +73,17 @@ add_identity_test(this, async function t
     do_check_true(diesel_coll.deleted);
 
   } finally {
     await promiseStopServer(server);
     Svc.Prefs.resetBranch("");
   }
 });
 
-add_identity_test(this, async function test_wipeServer_list_503() {
+add_task(async function test_wipeServer_list_503() {
   _("Service.wipeServer() deletes collections given as argument.");
 
   let steam_coll = new FakeCollection();
   let diesel_coll = new FakeCollection();
 
   let server = httpd_setup({
     "/1.1/johndoe/storage/steam": steam_coll.handler(),
     "/1.1/johndoe/storage/petrol": httpd_handler(503, "Service Unavailable"),
@@ -114,17 +114,17 @@ add_identity_test(this, async function t
     do_check_false(diesel_coll.deleted);
 
   } finally {
     await promiseStopServer(server);
     Svc.Prefs.resetBranch("");
   }
 });
 
-add_identity_test(this, async function test_wipeServer_all_success() {
+add_task(async function test_wipeServer_all_success() {
   _("Service.wipeServer() deletes all the things.");
 
   /**
    * Handle the bulk DELETE request sent by wipeServer.
    */
   let deleted = false;
   let serverTimestamp;
   function storageHandler(request, response) {
@@ -144,17 +144,17 @@ add_identity_test(this, async function t
   let returnedTimestamp = Service.wipeServer();
   do_check_true(deleted);
   do_check_eq(returnedTimestamp, serverTimestamp);
 
   await promiseStopServer(server);
   Svc.Prefs.resetBranch("");
 });
 
-add_identity_test(this, async function test_wipeServer_all_404() {
+add_task(async function test_wipeServer_all_404() {
   _("Service.wipeServer() accepts a 404.");
 
   /**
    * Handle the bulk DELETE request sent by wipeServer. Returns a 404.
    */
   let deleted = false;
   let serverTimestamp;
   function storageHandler(request, response) {
@@ -176,17 +176,17 @@ add_identity_test(this, async function t
   let returnedTimestamp = Service.wipeServer();
   do_check_true(deleted);
   do_check_eq(returnedTimestamp, serverTimestamp);
 
   await promiseStopServer(server);
   Svc.Prefs.resetBranch("");
 });
 
-add_identity_test(this, async function test_wipeServer_all_503() {
+add_task(async function test_wipeServer_all_503() {
   _("Service.wipeServer() throws if it encounters a non-200/404 response.");
 
   /**
    * Handle the bulk DELETE request sent by wipeServer. Returns a 503.
    */
   function storageHandler(request, response) {
     do_check_eq("DELETE", request.method);
     do_check_true(request.hasHeader("X-Confirm-Delete"));
@@ -208,17 +208,17 @@ add_identity_test(this, async function t
     error = ex;
   }
   do_check_eq(error.status, 503);
 
   await promiseStopServer(server);
   Svc.Prefs.resetBranch("");
 });
 
-add_identity_test(this, async function test_wipeServer_all_connectionRefused() {
+add_task(async function test_wipeServer_all_connectionRefused() {
   _("Service.wipeServer() throws if it encounters a network problem.");
   let server = httpd_setup({});
   await setUpTestFixtures(server);
 
   Service.serverURL = "http://localhost:4352/";
   Service.clusterURL = "http://localhost:4352/";
 
   _("Try deletion.");

--- a/services/sync/tests/unit/test_syncscheduler.js
+++ b/services/sync/tests/unit/test_syncscheduler.js
@@ -1,11 +1,12 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
+Cu.import("resource://services-sync/browserid_identity.js");
 Cu.import("resource://services-sync/constants.js");
 Cu.import("resource://services-sync/engines.js");
 Cu.import("resource://services-sync/engines/clients.js");
 Cu.import("resource://services-sync/policies.js");
 Cu.import("resource://services-sync/record.js");
 Cu.import("resource://services-sync/service.js");
 Cu.import("resource://services-sync/status.js");
 Cu.import("resource://services-sync/util.js");
@@ -154,17 +155,17 @@ add_test(function test_prefAttributes() 
   do_check_eq(scheduler.activeInterval, 60000);
   do_check_eq(scheduler.immediateInterval, 60000);
 
   Svc.Prefs.resetBranch("");
   scheduler.setDefaults();
   run_next_test();
 });
 
-add_identity_test(this, async function test_updateClientMode() {
+add_task(async function test_updateClientMode() {
   _("Test updateClientMode adjusts scheduling attributes based on # of clients appropriately");
   do_check_eq(scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.numClients > 1);
   do_check_false(scheduler.idle);
 
   // Trigger a change in interval & threshold by adding a client.
   clientsEngine._store.create(
@@ -186,17 +187,17 @@ add_identity_test(this, async function t
   do_check_eq(scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.numClients > 1);
   do_check_false(scheduler.idle);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_masterpassword_locked_retry_interval() {
+add_task(async function test_masterpassword_locked_retry_interval() {
   _("Test Status.login = MASTER_PASSWORD_LOCKED results in reschedule at MASTER_PASSWORD interval");
   let loginFailed = false;
   Svc.Obs.add("weave:service:login:error", function onLoginError() {
     Svc.Obs.remove("weave:service:login:error", onLoginError);
     loginFailed = true;
   });
 
   let rescheduleInterval = false;
@@ -223,17 +224,17 @@ add_identity_test(this, async function t
   do_check_true(rescheduleInterval);
 
   Service.verifyLogin = oldVerifyLogin;
   SyncScheduler.prototype.scheduleAtInterval = oldScheduleAtInterval;
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_calculateBackoff() {
+add_task(async function test_calculateBackoff() {
   do_check_eq(Status.backoffInterval, 0);
 
   // Test no interval larger than the maximum backoff is used if
   // Status.backoffInterval is smaller.
   Status.backoffInterval = 5;
   let backoffInterval = Utils.calculateBackoff(50, MAXIMUM_BACKOFF_INTERVAL,
                                                Status.backoffInterval);
 
@@ -245,29 +246,29 @@ add_identity_test(this, async function t
   backoffInterval = Utils.calculateBackoff(50, MAXIMUM_BACKOFF_INTERVAL,
                                            Status.backoffInterval);
 
   do_check_eq(backoffInterval, MAXIMUM_BACKOFF_INTERVAL + 10);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_scheduleNextSync_nowOrPast() {
+add_task(async function test_scheduleNextSync_nowOrPast() {
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   // We're late for a sync...
   scheduler.scheduleNextSync(-1);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_scheduleNextSync_future_noBackoff() {
+add_task(async function test_scheduleNextSync_future_noBackoff() {
   _("scheduleNextSync() uses the current syncInterval if no interval is provided.");
   // Test backoffInterval is 0 as expected.
   do_check_eq(Status.backoffInterval, 0);
 
   _("Test setting sync interval when nextSync == 0");
   scheduler.nextSync = 0;
   scheduler.scheduleNextSync();
 
@@ -306,17 +307,17 @@ add_identity_test(this, async function t
   // Request a sync at the smallest possible interval (0 triggers now).
   scheduler.scheduleNextSync(1);
   do_check_true(scheduler.nextSync <= Date.now() + 1);
   do_check_eq(scheduler.syncTimer.delay, 1);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_scheduleNextSync_future_backoff() {
+add_task(async function test_scheduleNextSync_future_backoff() {
  _("scheduleNextSync() will honour backoff in all scheduling requests.");
   // Let's take a backoff interval that's bigger than the default sync interval.
   const BACKOFF = 7337;
   Status.backoffInterval = scheduler.syncInterval + BACKOFF;
 
   _("Test setting sync interval when nextSync == 0");
   scheduler.nextSync = 0;
   scheduler.scheduleNextSync();
@@ -356,17 +357,17 @@ add_identity_test(this, async function t
   // Request a sync at the smallest possible interval (0 triggers now).
   scheduler.scheduleNextSync(1);
   do_check_true(scheduler.nextSync <= Date.now() + Status.backoffInterval);
   do_check_eq(scheduler.syncTimer.delay, Status.backoffInterval);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_handleSyncError() {
+add_task(async function test_handleSyncError() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Force sync to fail.
   Svc.Prefs.set("firstSync", "notReady");
 
   _("Ensure expected initial environment.");
   do_check_eq(scheduler._syncErrors, 0);
@@ -419,17 +420,17 @@ add_identity_test(this, async function t
   _("Arrange for a successful sync to reset the scheduler error count");
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
   Svc.Prefs.set("firstSync", "wipeRemote");
   scheduler.scheduleNextSync(-1);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_client_sync_finish_updateClientMode() {
+add_task(async function test_client_sync_finish_updateClientMode() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Confirm defaults.
   do_check_eq(scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.idle);
 
@@ -458,29 +459,29 @@ add_identity_test(this, async function t
   do_check_eq(scheduler.syncThreshold, SINGLE_USER_THRESHOLD);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
   do_check_false(scheduler.numClients > 1);
   do_check_false(scheduler.idle);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_autoconnect_nextSync_past() {
+add_task(async function test_autoconnect_nextSync_past() {
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
   // nextSync will be 0 by default, so it's way in the past.
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   scheduler.delayedAutoConnect(0);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_autoconnect_nextSync_future() {
+add_task(async function test_autoconnect_nextSync_future() {
   let previousSync = Date.now() + scheduler.syncInterval / 2;
   scheduler.nextSync = previousSync;
   // nextSync rounds to the nearest second.
   let expectedSync = scheduler.nextSync;
   let expectedInterval = expectedSync - Date.now() - 1000;
 
   // Ensure we don't actually try to sync (or log in for that matter).
   function onLoginStart() {
@@ -529,17 +530,17 @@ add_task(async function test_autoconnect
 
   Utils.mpLocked = origLocked;
   Utils.ensureMPUnlocked = origEnsureMPUnlocked;
   Service.identity._canFetchKeys = origCanFetchKeys;
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_no_autoconnect_during_wizard() {
+add_task(async function test_no_autoconnect_during_wizard() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Simulate the Sync setup wizard.
   Svc.Prefs.set("firstSync", "notReady");
 
   // Ensure we don't actually try to sync (or log in for that matter).
   function onLoginStart() {
@@ -548,18 +549,19 @@ add_identity_test(this, async function t
   Svc.Obs.add("weave:service:login:start", onLoginStart);
 
   scheduler.delayedAutoConnect(0);
   await promiseZeroTimer();
   Svc.Obs.remove("weave:service:login:start", onLoginStart);
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_no_autoconnect_status_not_ok() {
+add_task(async function test_no_autoconnect_status_not_ok() {
   let server = sync_httpd_setup();
+  Status.__authManager = Service.identity = new BrowserIDManager();
 
   // Ensure we don't actually try to sync (or log in for that matter).
   function onLoginStart() {
     do_throw("Should not get here!");
   }
   Svc.Obs.add("weave:service:login:start", onLoginStart);
 
   scheduler.delayedAutoConnect(0);
@@ -567,34 +569,34 @@ add_identity_test(this, async function t
   Svc.Obs.remove("weave:service:login:start", onLoginStart);
 
   do_check_eq(Status.service, CLIENT_NOT_CONFIGURED);
   do_check_eq(Status.login, LOGIN_FAILED_NO_USERNAME);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_autoconnectDelay_pref() {
+add_task(async function test_autoconnectDelay_pref() {
   let promiseObserved = promiseOneObserver("weave:service:sync:finish");
 
   Svc.Prefs.set("autoconnectDelay", 1);
 
   let server = sync_httpd_setup();
   await setUp(server);
 
   Svc.Obs.notify("weave:service:ready");
 
   // autoconnectDelay pref is multiplied by 1000.
   do_check_eq(scheduler._autoTimer.delay, 1000);
   do_check_eq(Status.service, STATUS_OK);
   await promiseObserved;
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_idle_adjustSyncInterval() {
+add_task(async function test_idle_adjustSyncInterval() {
   // Confirm defaults.
   do_check_eq(scheduler.idle, false);
 
   // Single device: nothing changes.
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
   do_check_eq(scheduler.idle, true);
   do_check_eq(scheduler.syncInterval, scheduler.singleDeviceInterval);
 
@@ -606,17 +608,17 @@ add_identity_test(this, async function t
   scheduler.updateClientMode();
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
   do_check_eq(scheduler.idle, true);
   do_check_eq(scheduler.syncInterval, scheduler.idleInterval);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_back_triggersSync() {
+add_task(async function test_back_triggersSync() {
   // Confirm defaults.
   do_check_false(scheduler.idle);
   do_check_eq(Status.backoffInterval, 0);
 
   // Set up: Define 2 clients and put the system in idle.
   scheduler.numClients = 2;
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
   do_check_true(scheduler.idle);
@@ -626,17 +628,17 @@ add_identity_test(this, async function t
   let promiseObserved = promiseOneObserver("weave:service:login:error");
 
   // Send an 'active' event to trigger sync soonish.
   scheduler.observe(null, "active", Svc.Prefs.get("scheduler.idleTime"));
   await promiseObserved;
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_active_triggersSync_observesBackoff() {
+add_task(async function test_active_triggersSync_observesBackoff() {
   // Confirm defaults.
   do_check_false(scheduler.idle);
 
   // Set up: Set backoff, define 2 clients and put the system in idle.
   const BACKOFF = 7337;
   Status.backoffInterval = scheduler.idleInterval + BACKOFF;
   scheduler.numClients = 2;
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
@@ -655,17 +657,17 @@ add_identity_test(this, async function t
   Svc.Obs.remove("weave:service:login:start", onLoginStart);
 
   do_check_true(scheduler.nextSync <= Date.now() + Status.backoffInterval);
   do_check_eq(scheduler.syncTimer.delay, Status.backoffInterval);
 
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_back_debouncing() {
+add_task(async function test_back_debouncing() {
   _("Ensure spurious back-then-idle events, as observed on OS X, don't trigger a sync.");
 
   // Confirm defaults.
   do_check_eq(scheduler.idle, false);
 
   // Set up: Define 2 clients and put the system in idle.
   scheduler.numClients = 2;
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
@@ -680,17 +682,17 @@ add_identity_test(this, async function t
   scheduler.observe(null, "active", Svc.Prefs.get("scheduler.idleTime"));
   scheduler.observe(null, "idle", Svc.Prefs.get("scheduler.idleTime"));
 
   await promiseNamedTimer(IDLE_OBSERVER_BACK_DELAY * 1.5, {}, "timer");
   Svc.Obs.remove("weave:service:login:start", onLoginStart);
   await cleanUpAndGo();
 });
 
-add_identity_test(this, async function test_no_sync_node() {
+add_task(async function test_no_sync_node() {
   // Test when Status.sync == NO_SYNC_NODE_FOUND
   // it is not overwritten on sync:finish
   let server = sync_httpd_setup();
   await setUp(server);
 
   oldfc = Service._clusterManager._findCluster;
   Service._clusterManager._findCluster = () => null;
   Service.clusterURL = "";
@@ -700,17 +702,17 @@ add_identity_test(this, async function t
     do_check_eq(scheduler.syncTimer.delay, NO_SYNC_NODE_INTERVAL);
 
     await cleanUpAndGo(server);
   } finally {
     Service._clusterManager._findCluster = oldfc;
   }
 });
 
-add_identity_test(this, async function test_sync_failed_partial_500s() {
+add_task(async function test_sync_failed_partial_500s() {
   _("Test a 5xx status calls handleSyncError.");
   scheduler._syncErrors = MAX_ERROR_COUNT_BEFORE_BACKOFF;
   let server = sync_httpd_setup();
 
   let engine = Service.engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 500};
 
@@ -727,17 +729,17 @@ add_identity_test(this, async function t
   do_check_true(Status.enforceBackoff);
   do_check_eq(scheduler._syncErrors, 4);
   do_check_true(scheduler.nextSync <= (Date.now() + maxInterval));
   do_check_true(scheduler.syncTimer.delay <= maxInterval);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_sync_failed_partial_400s() {
+add_task(async function test_sync_failed_partial_400s() {
   _("Test a non-5xx status doesn't call handleSyncError.");
   scheduler._syncErrors = MAX_ERROR_COUNT_BEFORE_BACKOFF;
   let server = sync_httpd_setup();
 
   let engine = Service.engineManager.get("catapult");
   engine.enabled = true;
   engine.exception = {status: 400};
 
@@ -759,17 +761,17 @@ add_identity_test(this, async function t
   do_check_false(Status.enforceBackoff);
   do_check_eq(scheduler._syncErrors, 0);
   do_check_true(scheduler.nextSync <= (Date.now() + scheduler.activeInterval));
   do_check_true(scheduler.syncTimer.delay <= scheduler.activeInterval);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_sync_X_Weave_Backoff() {
+add_task(async function test_sync_X_Weave_Backoff() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Use an odd value on purpose so that it doesn't happen to coincide with one
   // of the sync intervals.
   const BACKOFF = 7337;
 
   // Extend info/collections so that we can put it into server maintenance mode.
@@ -816,17 +818,17 @@ add_identity_test(this, async function t
 
   // Verify that the next sync is actually going to wait that long.
   do_check_true(scheduler.nextSync >= Date.now() + minimumExpectedDelay);
   do_check_true(scheduler.syncTimer.delay >= minimumExpectedDelay);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_sync_503_Retry_After() {
+add_task(async function test_sync_503_Retry_After() {
   let server = sync_httpd_setup();
   await setUp(server);
 
   // Use an odd value on purpose so that it doesn't happen to coincide with one
   // of the sync intervals.
   const BACKOFF = 7337;
 
   // Extend info/collections so that we can put it into server maintenance mode.
@@ -877,17 +879,17 @@ add_identity_test(this, async function t
 
   // Verify that the next sync is actually going to wait that long.
   do_check_true(scheduler.nextSync >= Date.now() + minimumExpectedDelay);
   do_check_true(scheduler.syncTimer.delay >= minimumExpectedDelay);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_loginError_recoverable_reschedules() {
+add_task(async function test_loginError_recoverable_reschedules() {
   _("Verify that a recoverable login error schedules a new sync.");
   await configureIdentity({username: "johndoe@mozilla.com"});
   Service.serverURL = "http://localhost:1234/";
   Service.clusterURL = Service.serverURL;
   Status.resetSync(); // reset Status.login
 
   let promiseObserved = promiseOneObserver("weave:service:login:error");
 
@@ -917,17 +919,17 @@ add_identity_test(this, async function t
   do_check_true(scheduler.nextSync <= expectedNextSync);
   do_check_true(scheduler.syncTimer.delay > 0);
   do_check_true(scheduler.syncTimer.delay <= scheduler.syncInterval);
 
   Svc.Obs.remove("weave:service:sync:start", onSyncStart);
   await cleanUpAndGo()
 });
 
-add_identity_test(this, async function test_loginError_fatal_clearsTriggers() {
+add_task(async function test_loginError_fatal_clearsTriggers() {
   _("Verify that a fatal login error clears sync triggers.");
   await configureIdentity({username: "johndoe@mozilla.com"});
 
   let server = httpd_setup({
     "/1.1/johndoe@mozilla.com/info/collections": httpd_handler(401, "Unauthorized")
   });
 
   Service.serverURL = server.baseURI + "/";
@@ -951,17 +953,17 @@ add_identity_test(this, async function t
   do_check_eq(Status.login, LOGIN_FAILED_NETWORK_ERROR);
   // syncs should still be scheduled.
   do_check_true(scheduler.nextSync > Date.now());
   do_check_true(scheduler.syncTimer.delay > 0);
 
   await cleanUpAndGo(server);
 });
 
-add_identity_test(this, async function test_proper_interval_on_only_failing() {
+add_task(async function test_proper_interval_on_only_failing() {
   _("Ensure proper behavior when only failed records are applied.");
 
   // If an engine reports that no records succeeded, we shouldn't decrease the
   // sync interval.
   do_check_false(scheduler.hasIncomingItems);
   const INTERVAL = 10000000;
   scheduler.syncInterval = INTERVAL;
 

--- a/services/sync/tests/unit/test_telemetry.js
+++ b/services/sync/tests/unit/test_telemetry.js
@@ -64,17 +64,17 @@ async function cleanAndGo(engine, server
   Service.recordManager.clearCache();
   engine._tracker.clearChangedIDs();
   await promiseStopServer(server);
 }
 
 // Avoid addon manager complaining about not being initialized
 Service.engineManager.unregister("addons");
 
-add_identity_test(this, async function test_basic() {
+add_task(async function test_basic() {
   let helper = track_collections_helper();
   let upd = helper.with_updated_collection;
 
   let handlers = {
     "/1.1/johndoe/info/collections": helper.handler,
     "/1.1/johndoe/storage/crypto/keys": upd("crypto", new ServerWBO("keys").handler()),
     "/1.1/johndoe/storage/meta/global": upd("meta", new ServerWBO("global").handler())
   };
@@ -456,17 +456,17 @@ add_task(async function test_nserror() {
       code: Cr.NS_ERROR_UNKNOWN_HOST
     });
   } finally {
     await cleanAndGo(engine, server);
     Service.engineManager.unregister(engine);
   }
 });
 
-add_identity_test(this, async function test_discarding() {
+add_task(async function test_discarding() {
   let helper = track_collections_helper();
   let upd = helper.with_updated_collection;
   let telem = get_sync_test_telemetry();
   telem.maxPayloadCount = 2;
   telem.submissionInterval = Infinity;
   let oldSubmit = telem.submit;
 
   let server;

--- a/tools/lint/eslint/modules.json
+++ b/tools/lint/eslint/modules.json
@@ -216,17 +216,17 @@
   "Timer.jsm": ["setTimeout", "clearTimeout", "setInterval", "clearInterval"],
   "tokenserverclient.js": ["TokenServerClient", "TokenServerClientError", "TokenServerClientNetworkError", "TokenServerClientServerError"],
   "ToolboxProcess.jsm": ["BrowserToolboxProcess"],
   "tps.jsm": ["ACTIONS", "TPS"],
   "Translation.jsm": ["Translation", "TranslationTelemetry"],
   "Traversal.jsm": ["TraversalRules", "TraversalHelper"],
   "UpdateTelemetry.jsm": ["AUSTLMY"],
   "util.js": ["getChromeWindow", "XPCOMUtils", "Services", "Utils", "Async", "Svc", "Str"],
-  "utils.js": ["applicationName", "assert", "Copy", "getBrowserObject", "getChromeWindow", "getWindows", "getWindowByTitle", "getWindowByType", "getWindowId", "getMethodInWindows", "getPreference", "saveDataURL", "setPreference", "sleep", "startTimer", "stopTimer", "takeScreenshot", "unwrapNode", "waitFor", "btoa", "encryptPayload", "makeIdentityConfig", "makeFxAccountsInternalMock", "configureFxAccountIdentity", "configureIdentity", "SyncTestingInfrastructure", "waitForZeroTimer", "Promise", "add_identity_test", "MockFxaStorageManager", "AccountState", "sumHistogram", "CommonUtils", "CryptoUtils", "TestingUtils"],
+  "utils.js": ["applicationName", "assert", "Copy", "getBrowserObject", "getChromeWindow", "getWindows", "getWindowByTitle", "getWindowByType", "getWindowId", "getMethodInWindows", "getPreference", "saveDataURL", "setPreference", "sleep", "startTimer", "stopTimer", "takeScreenshot", "unwrapNode", "waitFor", "btoa", "encryptPayload", "makeIdentityConfig", "makeFxAccountsInternalMock", "configureFxAccountIdentity", "configureIdentity", "SyncTestingInfrastructure", "waitForZeroTimer", "Promise", "MockFxaStorageManager", "AccountState", "sumHistogram", "CommonUtils", "CryptoUtils", "TestingUtils"],
   "Utils.jsm": ["Utils", "Logger", "PivotContext", "PrefCache"],
   "VariablesView.jsm": ["VariablesView", "escapeHTML"],
   "VariablesViewController.jsm": ["VariablesViewController", "StackFrameUtils"],
   "version.jsm": ["VERSION"],
   "vtt.jsm": ["WebVTT"],
   "WebChannel.jsm": ["WebChannel", "WebChannelBroker"],
   "WindowDraggingUtils.jsm": ["WindowDraggingElement"],
   "windows.js": ["init", "map"],