--- a/toolkit/components/extensions/test/xpcshell/test_ext_telemetry.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_telemetry.js
@@ -1,15 +1,15 @@
 "use strict";
 
 ChromeUtils.import("resource://gre/modules/TelemetryArchive.jsm", this);
 
 function createExtension(backgroundScript, permissions) {
   let extensionData = {
-    background: `(${backgroundScript})()`,
+    background: backgroundScript,
     manifest: {permissions},
   };
   return ExtensionTestUtils.loadExtension(extensionData);
 }
 
 async function run(test) {
   let extension = createExtension(test.backgroundScript, test.permissions || ["telemetry"]);
   await extension.startup();
@@ -25,34 +25,31 @@ add_task(async function test_telemetry_w
     },
     permissions: [],
     doneSignal: "telemetry_permission",
   });
 });
 
 add_task(async function test_telemetry_scalar_add() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.scalarAdd("telemetry.test.unsigned_int_kind", 1)
-        .then(() => {
-          browser.test.notifyPass("scalar_add");
-        });
+    backgroundScript: async () => {
+      // TODO: verify value
+      await browser.telemetry.scalarAdd("telemetry.test.unsigned_int_kind", 1);
+      browser.test.notifyPass("scalar_add");
     },
     doneSignal: "scalar_add",
   });
 });
 
 add_task(async function test_telemetry_scalar_add_unknown_name() {
-  let {messages} = await promiseConsoleOutput(async function() {
+  let {messages} = await promiseConsoleOutput(async () => {
     await run({
-      backgroundScript: () => {
-        browser.telemetry.scalarAdd("telemetry.test.does_not_exist", 1)
-          .then(() => {
-            browser.test.notifyPass("scalar_add_unknown_name");
-          });
+      backgroundScript: async () => {
+        await browser.telemetry.scalarAdd("telemetry.test.does_not_exist", 1);
+        browser.test.notifyPass("scalar_add_unknown_name");
       },
       doneSignal: "scalar_add_unknown_name",
     });
   });
 
   messages = messages.filter(msg => /telemetry.test.does_not_exist - Unknown scalar./);
   equal(messages.length, 1, "Telemetry should throw if an unknown scalar is incremented");
 });
@@ -69,79 +66,69 @@ add_task(async function test_telemetry_s
     },
     doneSignal: "scalar_add_illegal_value",
   });
 });
 
 add_task(async function test_telemetry_scalar_add_invalid_keyed_scalar() {
   let {messages} = await promiseConsoleOutput(async function() {
     await run({
-      backgroundScript: () => {
-        browser.telemetry.scalarAdd("telemetry.test.keyed_unsigned_int", 1)
-          .then(() => {
-            browser.test.notifyPass("scalar_add_invalid_keyed_scalar");
-          });
+      backgroundScript: async () => {
+        await browser.telemetry.scalarAdd("telemetry.test.keyed_unsigned_int", 1);
+        browser.test.notifyPass("scalar_add_invalid_keyed_scalar");
       },
       doneSignal: "scalar_add_invalid_keyed_scalar",
     });
   });
 
   messages = messages.filter(msg => /Attempting to manage a keyed scalar as a scalar/);
   equal(messages.length, 1, "Telemetry should throw if a keyed scalar is incremented");
 });
 
 add_task(async function test_telemetry_scalar_set() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.scalarSet("telemetry.test.boolean_kind", true)
-        .then(() => {
-          browser.test.notifyPass("scalar_set");
-        });
+    backgroundScript: async () => {
+      await browser.telemetry.scalarSet("telemetry.test.boolean_kind", true);
+      browser.test.notifyPass("scalar_set");
     },
     doneSignal: "scalar_set",
   });
 });
 
 add_task(async function test_telemetry_scalar_set_unknown_name() {
   let {messages} = await promiseConsoleOutput(async function() {
     await run({
-      backgroundScript: () => {
-        browser.telemetry.scalarSet("telemetry.test.does_not_exist", true)
-          .then(() => {
-            browser.test.notifyPass("scalar_set_unknown_name");
-          });
+      backgroundScript: async () => {
+        await browser.telemetry.scalarSet("telemetry.test.does_not_exist", true);
+        browser.test.notifyPass("scalar_set_unknown_name");
       },
       doneSignal: "scalar_set_unknown_name",
     });
   });
 
   messages = messages.filter(msg => /Unknown scalar/);
   equal(messages.length, 1, "Telemetry should throw if an unknown scalar is set");
 });
 
 add_task(async function test_telemetry_scalar_set_maximum() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.scalarSetMaximum("telemetry.test.unsigned_int_kind", 123)
-        .then(() => {
-          browser.test.notifyPass("scalar_set_maximum");
-        });
+    backgroundScript: async () => {
+      await browser.telemetry.scalarSetMaximum("telemetry.test.unsigned_int_kind", 123);
+      browser.test.notifyPass("scalar_set_maximum");
     },
     doneSignal: "scalar_set_maximum",
   });
 });
 
 add_task(async function test_telemetry_scalar_set_maximum_unknown_name() {
   let {messages} = await promiseConsoleOutput(async function() {
     await run({
-      backgroundScript: () => {
-        browser.telemetry.scalarSetMaximum("telemetry.test.does_not_exist", 1)
-        .then(() => {
-          browser.test.notifyPass("scalar_set_maximum_unknown_name");
-        });
+      backgroundScript: async () => {
+        await browser.telemetry.scalarSetMaximum("telemetry.test.does_not_exist", 1);
+        browser.test.notifyPass("scalar_set_maximum_unknown_name");
       },
       doneSignal: "scalar_set_maximum_unknown_name",
     });
   });
 
   messages = messages.filter(msg => /Unknown scalar/);
   equal(messages.length, 1, "Telemetry should throw if an unknown scalar is set");
 });
@@ -158,158 +145,144 @@ add_task(async function test_telemetry_s
     doneSignal: "scalar_set_maximum_illegal_value",
   });
 });
 
 add_task(async function test_telemetry_record_event() {
   Services.telemetry.setEventRecordingEnabled("telemetry.test", true);
 
   await run({
-    backgroundScript: () => {
-      browser.telemetry.recordEvent("telemetry.test", "test1", "object1")
-        .then(() => {
-          browser.test.notifyPass("record_event_ok");
-        });
+    backgroundScript: async () => {
+      await browser.telemetry.recordEvent("telemetry.test", "test1", "object1");
+      browser.test.notifyPass("record_event_ok");
     },
     doneSignal: "record_event_ok",
   });
 
   let events = Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(events.parent.length, 1);
   equal(events.parent[0][1], "telemetry.test");
 
   Services.telemetry.clearEvents();
 });
 
 add_task(async function test_telemetry_register_scalars_string() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.registerScalars("telemetry.test.dynamic", {
+    backgroundScript: async () => {
+      await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_string": {
           kind: browser.telemetry.ScalarType.STRING,
           keyed: false,
           record_on_release: true,
         },
-      }).then(() => {
-        return browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
-      }).then(() => {
-        browser.test.notifyPass("register_scalars_string");
       });
+      await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
+      browser.test.notifyPass("register_scalars_string");
     },
     doneSignal: "register_scalars_string",
   });
 
   const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string"], "hello");
 });
 
 add_task(async function test_telemetry_register_scalars_multiple() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.registerScalars("telemetry.test.dynamic", {
+    backgroundScript: async () => {
+      await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_string": {
           kind: browser.telemetry.ScalarType.STRING,
           keyed: false,
           record_on_release: true,
         },
         "webext_string_too": {
           kind: browser.telemetry.ScalarType.STRING,
           keyed: false,
           record_on_release: true,
         },
-      }).then(() => {
-        return browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
-      }).then(() => {
-        return browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string_too", "world");
-      }).then(() => {
-        browser.test.notifyPass("register_scalars_multiple");
       });
+      await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
+      await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string_too", "world");
+      browser.test.notifyPass("register_scalars_multiple");
     },
     doneSignal: "register_scalars_multiple",
   });
 
   const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string"], "hello");
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string_too"], "world");
 });
 
 add_task(async function test_telemetry_register_scalars_boolean() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.registerScalars("telemetry.test.dynamic", {
+    backgroundScript: async () => {
+      await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_boolean": {
           kind: browser.telemetry.ScalarType.BOOLEAN,
           keyed: false,
           record_on_release: true,
         },
-      }).then(() => {
-        return browser.telemetry.scalarSet("telemetry.test.dynamic.webext_boolean", true);
-      }).then(() => {
-        browser.test.notifyPass("register_scalars_boolean");
       });
+      await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_boolean", true);
+      browser.test.notifyPass("register_scalars_boolean");
     },
     doneSignal: "register_scalars_boolean",
   });
 
   const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_boolean"], true);
 });
 
 add_task(async function test_telemetry_register_scalars_count() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.registerScalars("telemetry.test.dynamic", {
+    backgroundScript: async () => {
+      await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_count": {
           kind: browser.telemetry.ScalarType.COUNT,
           keyed: false,
           record_on_release: true,
         },
-      }).then(() => {
-        return browser.telemetry.scalarSet("telemetry.test.dynamic.webext_count", 123);
-      }).then(() => {
-        browser.test.notifyPass("register_scalars_count");
       });
+      await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_count", 123);
+      browser.test.notifyPass("register_scalars_count");
     },
     doneSignal: "register_scalars_count",
   });
 
   const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_count"], 123);
 });
 
 add_task(async function test_telemetry_register_events() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.registerEvents("telemetry.test.dynamic", {
+    backgroundScript: async () => {
+      await browser.telemetry.registerEvents("telemetry.test.dynamic", {
         "test1": {
           methods: ["test1"],
           objects: ["object1"],
           extra_keys: [],
         },
-      }).then(() => {
-        return browser.telemetry.recordEvent("telemetry.test.dynamic", "test1", "object1");
-      }).then(() => {
-        browser.test.notifyPass("register_events");
       });
+      await browser.telemetry.recordEvent("telemetry.test.dynamic", "test1", "object1");
+      browser.test.notifyPass("register_events");
     },
     doneSignal: "register_events",
   });
 
   let events = Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   let expected = [["telemetry.test.dynamic", "test1", "object1"]];
   equal(events.dynamic.length, expected.length);
   deepEqual(events.dynamic.map(e => e.slice(1)), expected);
 });
 
 add_task(async function test_telemetry_submit_ping() {
   await run({
-    backgroundScript: () => {
-      browser.telemetry.submitPing("webext-test", {}, {})
-        .then(() => { browser.test.notifyPass("submit_ping"); },
-              ex => { browser.test.notifyFail("submit_ping", ex); });
+    backgroundScript: async () => {
+      await browser.telemetry.submitPing("webext-test", {}, {});
+      browser.test.notifyPass("submit_ping");
     },
     doneSignal: "submit_ping",
   });
 
   let pings = await TelemetryArchive.promiseArchivedPingList();
   equal(pings.length, 1);
   equal(pings[0].type, "webext-test");
 });