--- a/devtools/shared/discovery/tests/unit/test_discovery.js
+++ b/devtools/shared/discovery/tests/unit/test_discovery.js
@@ -69,17 +69,17 @@ discovery._factories.Transport = TestTra
 
 // Ignore name generation on b2g and force a fixed value
 Object.defineProperty(discovery.device, "name", {
   get: function () {
     return "test-device";
   }
 });
 
-add_task(async function() {
+add_task(async function () {
   // At startup, no remote devices are known
   deepEqual(discovery.getRemoteDevicesWithService("devtools"), []);
   deepEqual(discovery.getRemoteDevicesWithService("penguins"), []);
 
   discovery.scan();
 
   // No services added yet, still empty
   deepEqual(discovery.getRemoteDevicesWithService("devtools"), []);

--- a/devtools/shared/fronts/inspector.js
+++ b/devtools/shared/fronts/inspector.js
@@ -202,17 +202,17 @@ const WalkerFront = FrontClassWithSpec(w
    * query will send the next result. When there are no more results to be sent
    * back, null is sent.
    * @param {String} query
    * @param {Object} options
    *    - "reverse": search backwards
    *    - "selectorOnly": treat input as a selector string (don't search text
    *                      tags, attributes, etc)
    */
-  search: custom(async function(query, options = { }) {
+  search: custom(async function (query, options = { }) {
     let nodeList;
     let searchType;
     let searchData = this.searchData = this.searchData || { };
     let selectorOnly = !!options.selectorOnly;
 
     if (selectorOnly) {
       searchType = "selector";
       nodeList = await this.multiFrameQuerySelectorAll(query);
@@ -432,17 +432,17 @@ const WalkerFront = FrontClassWithSpec(w
     // Fetch and process the mutations.
     this.getMutations({cleanup: this.autoCleanup}).catch(() => {});
   }),
 
   isLocal: function () {
     return !!this.conn._transport._serverConnection;
   },
 
-  removeNode: custom(async function(node) {
+  removeNode: custom(async function (node) {
     let previousSibling = await this.previousSibling(node);
     let nextSibling = await this._removeNode(node);
     return {
       previousSibling: previousSibling,
       nextSibling: nextSibling,
     };
   }, {
     impl: "_removeNode"
@@ -489,17 +489,17 @@ var InspectorFront = FrontClassWithSpec(
       return this.getWalker().then(() => {
         return pageStyle;
       });
     });
   }, {
     impl: "_getPageStyle"
   }),
 
-  pickColorFromPage: custom(async function(toolbox, options) {
+  pickColorFromPage: custom(async function (toolbox, options) {
     if (toolbox) {
       // If the eyedropper was already started using the gcli command, hide it so we don't
       // end up with 2 instances of the eyedropper on the page.
       CommandUtils.executeOnTarget(toolbox.target, "eyedropper --hide");
     }
 
     await this._pickColorFromPage(options);
   }, {

--- a/devtools/shared/fronts/memory.js
+++ b/devtools/shared/fronts/memory.js
@@ -36,17 +36,17 @@ const MemoryFront = protocol.FrontClassW
    *         the server and client share a file system.
    *
    * @params {Object|undefined} options.boundaries
    *         The boundaries for the heap snapshot. See
    *         ChromeUtils.webidl for more details.
    *
    * @returns Promise<String>
    */
-  saveHeapSnapshot: protocol.custom(async function(options = {}) {
+  saveHeapSnapshot: protocol.custom(async function (options = {}) {
     const snapshotId = await this._saveHeapSnapshotImpl(options.boundaries);
 
     if (!options.forceCopy &&
         (await HeapSnapshotFileUtils.haveHeapSnapshotTempFile(snapshotId))) {
       return HeapSnapshotFileUtils.getHeapSnapshotTempFilePath(snapshotId);
     }
 
     return await this.transferHeapSnapshot(snapshotId);
@@ -75,17 +75,17 @@ const MemoryFront = protocol.FrontClassW
     });
 
     return new Promise((resolve, reject) => {
       const outFilePath =
         HeapSnapshotFileUtils.getNewUniqueHeapSnapshotTempFilePath();
       const outFile = new FileUtils.File(outFilePath);
 
       const outFileStream = FileUtils.openSafeFileOutputStream(outFile);
-      request.on("bulk-reply", async function({ copyTo }) {
+      request.on("bulk-reply", async function ({ copyTo }) {
         await copyTo(outFileStream);
         FileUtils.closeSafeFileOutputStream(outFileStream);
         resolve(outFilePath);
       });
     });
   })
 });
 

--- a/devtools/shared/fronts/performance.js
+++ b/devtools/shared/fronts/performance.js
@@ -24,17 +24,17 @@ const PerformanceFront = FrontClassWithS
   destroy: function () {
     Front.prototype.destroy.call(this);
   },
 
   /**
    * Conenct to the server, and handle once-off tasks like storing traits
    * or system info.
    */
-  connect: custom(async function() {
+  connect: custom(async function () {
     let systemClient = await getSystemInfo();
     let { traits } = await this._connect({ systemClient });
     this._traits = traits;
 
     return this._traits;
   }, {
     impl: "_connect"
   }),

--- a/devtools/shared/fronts/styles.js
+++ b/devtools/shared/fronts/styles.js
@@ -51,17 +51,17 @@ const PageStyleFront = FrontClassWithSpe
   getMatchedSelectors: custom(function (node, property, options) {
     return this._getMatchedSelectors(node, property, options).then(ret => {
       return ret.matched;
     });
   }, {
     impl: "_getMatchedSelectors"
   }),
 
-  getApplied: custom(async function(node, options = {}) {
+  getApplied: custom(async function (node, options = {}) {
     // If the getApplied method doesn't recreate the style cache itself, this
     // means a call to cssLogic.highlight is required before trying to access
     // the applied rules. Issue a request to getLayout if this is the case.
     // See https://bugzilla.mozilla.org/show_bug.cgi?id=1103993#c16.
     if (!this._form.traits || !this._form.traits.getAppliedCreatesStyleCache) {
       await this.getLayout(node);
     }
     let ret = await this._getApplied(node, options);
@@ -248,17 +248,17 @@ const StyleRuleFront = FrontClassWithSpe
         if (!source) {
           location.href = this.href;
         }
         this._originalLocation = location;
         return location;
       });
   },
 
-  modifySelector: custom(async function(node, value) {
+  modifySelector: custom(async function (node, value) {
     let response;
     if (this.supportsModifySelectorUnmatched) {
       // If the debugee supports adding unmatched rules (post FF41)
       if (this.canSetRuleText) {
         response = await this.modifySelector2(node, value, true);
       } else {
         response = await this.modifySelector2(node, value);
       }

--- a/devtools/shared/fronts/stylesheets.js
+++ b/devtools/shared/fronts/stylesheets.js
@@ -125,17 +125,17 @@ const StyleSheetFront = FrontClassWithSp
    */
   guessIndentation: function () {
     let prefIndent = getIndentationFromPrefs();
     if (prefIndent) {
       let {indentUnit, indentWithTabs} = prefIndent;
       return promise.resolve(indentWithTabs ? "\t" : " ".repeat(indentUnit));
     }
 
-    return (async function() {
+    return (async function () {
       let longStr = await this.getText();
       let source = await longStr.string();
 
       let {indentUnit, indentWithTabs} = getIndentationFromString(source);
 
       return indentWithTabs ? "\t" : " ".repeat(indentUnit);
     }.bind(this))();
   }

--- a/devtools/shared/heapsnapshot/tests/unit/test_DominatorTree_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_DominatorTree_02.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test that we can compute dominator trees from a snapshot in a worker.
 
-add_task(async function() {
+add_task(async function () {
   const worker = new ChromeWorker("resource://test/dominator-tree-worker.js");
   worker.postMessage({});
 
   let assertionCount = 0;
   worker.onmessage = e => {
     if (e.data.type !== "assertion") {
       return;
     }

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_computeDominatorTree_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_computeDominatorTree_01.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test the HeapAnalyses{Client,Worker} "computeDominatorTree" request.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
   equal(typeof dominatorTreeId, "number",

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_computeDominatorTree_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_computeDominatorTree_02.js
@@ -1,16 +1,16 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test the HeapAnalyses{Client,Worker} "computeDominatorTree" request with bad
 // file paths.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   let threw = false;
   try {
     await client.computeDominatorTree("/etc/passwd");
   } catch (_) {
     threw = true;
   }

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_01.js
@@ -7,17 +7,17 @@
 const breakdown = {
   by: "coarseType",
   objects: { by: "count", count: true, bytes: true },
   scripts: { by: "count", count: true, bytes: true },
   strings: { by: "count", count: true, bytes: true },
   other: { by: "count", count: true, bytes: true },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   let dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
   ok(true, "Should have computed the dominator tree");

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_02.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test deleteHeapSnapshot is a noop if the provided path matches no snapshot
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   let threw = false;
   try {
     await client.deleteHeapSnapshot("path-does-not-exist");
   } catch (_) {
     threw = true;
   }

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_03.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_deleteHeapSnapshot_03.js
@@ -14,17 +14,17 @@ const breakdown = {
 
 function* createSnapshotAndDominatorTree(client) {
   let snapshotFilePath = saveNewHeapSnapshot();
   yield client.readHeapSnapshot(snapshotFilePath);
   let dominatorTreeId = yield client.computeDominatorTree(snapshotFilePath);
   return { dominatorTreeId, snapshotFilePath };
 }
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   let savedSnapshots = [
     await createSnapshotAndDominatorTree(client),
     await createSnapshotAndDominatorTree(client),
     await createSnapshotAndDominatorTree(client)
   ];
   ok(true, "Create 3 snapshots and dominator trees");

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCensusIndividuals_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCensusIndividuals_01.js
@@ -16,17 +16,17 @@ const CENSUS_BREAKDOWN = {
 
 const LABEL_BREAKDOWN = {
   by: "internalType",
   then: COUNT,
 };
 
 const MAX_INDIVIDUALS = 10;
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
   ok(true, "Should have computed dominator tree");

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCreationTime_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getCreationTime_01.js
@@ -12,17 +12,17 @@ function waitForThirtyMilliseconds() {
   }
 }
 
 const BREAKDOWN = {
   by: "internalType",
   then: { by: "count", count: true, bytes: true }
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
   const start = Date.now() * 1000;
 
   // Because Date.now() is less precise than the snapshot's time stamp, give it
   // a little bit of head room. Additionally, WinXP's timers have a granularity
   // of only +/-15 ms.
   waitForThirtyMilliseconds();
   const snapshotFilePath = saveNewHeapSnapshot();

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getDominatorTree_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getDominatorTree_01.js
@@ -7,17 +7,17 @@
 const breakdown = {
   by: "coarseType",
   objects: { by: "count", count: true, bytes: true },
   scripts: { by: "count", count: true, bytes: true },
   strings: { by: "count", count: true, bytes: true },
   other: { by: "count", count: true, bytes: true },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
   equal(typeof dominatorTreeId, "number",

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getDominatorTree_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getDominatorTree_02.js
@@ -8,17 +8,17 @@
 const breakdown = {
   by: "coarseType",
   objects: { by: "count", count: true, bytes: true },
   scripts: { by: "count", count: true, bytes: true },
   strings: { by: "count", count: true, bytes: true },
   other: { by: "count", count: true, bytes: true },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   let threw = false;
   try {
     await client.getDominatorTree({ dominatorTreeId: 42, breakdown });
   } catch (_) {
     threw = true;
   }

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getImmediatelyDominated_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_getImmediatelyDominated_01.js
@@ -7,17 +7,17 @@
 const breakdown = {
   by: "coarseType",
   objects: { by: "count", count: true, bytes: true },
   scripts: { by: "count", count: true, bytes: true },
   strings: { by: "count", count: true, bytes: true },
   other: { by: "count", count: true, bytes: true },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   const dominatorTreeId = await client.computeDominatorTree(snapshotFilePath);
 
   const partialTree = await client.getDominatorTree({
     dominatorTreeId,

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_readHeapSnapshot_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_readHeapSnapshot_01.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test that the HeapAnalyses{Client,Worker} can read heap snapshots.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   client.destroy();
 });

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensusDiff_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensusDiff_01.js
@@ -5,17 +5,17 @@
 // Test that the HeapAnalyses{Client,Worker} can take diffs between censuses.
 
 const BREAKDOWN = {
   by: "objectClass",
   then: { by: "count", count: true, bytes: false },
   other: { by: "count", count: true, bytes: false },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const markers = [allocationMarker()];
 
   const firstSnapshotFilePath = saveNewHeapSnapshot();
 
   // Allocate and hold an additional AllocationMarker object so we can see it in
   // the next heap snapshot.

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensusDiff_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensusDiff_02.js
@@ -21,17 +21,17 @@ const BREAKDOWN = {
     then: { by: "count", count: true, bytes: true },
   },
   other: {
     by: "internalType",
     then: { by: "count", count: true, bytes: true },
   },
 };
 
-add_task(async function() {
+add_task(async function () {
   const firstSnapshotFilePath = saveNewHeapSnapshot();
   const secondSnapshotFilePath = saveNewHeapSnapshot();
 
   const client = new HeapAnalysesClient();
   await client.readHeapSnapshot(firstSnapshotFilePath);
   await client.readHeapSnapshot(secondSnapshotFilePath);
 
   ok(true, "Should have read both heap snapshot files");

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_01.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_01.js
@@ -1,15 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test that the HeapAnalyses{Client,Worker} can take censuses.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const { report } = await client.takeCensus(snapshotFilePath);
   ok(report, "Should get a report");

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_02.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_02.js
@@ -1,16 +1,16 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test that the HeapAnalyses{Client,Worker} can take censuses with breakdown
 // options.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const { report } = await client.takeCensus(snapshotFilePath, {
     breakdown: { by: "count", count: true, bytes: true }

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_03.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_03.js
@@ -1,16 +1,16 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 "use strict";
 
 // Test that the HeapAnalyses{Client,Worker} bubbles errors properly when things
 // go wrong.
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   // Snapshot file path to a file that doesn't exist.
   let failed = false;
   try {
     await client.readHeapSnapshot(getFilePath("foo-bar-baz" + Math.random(), true));
   } catch (e) {
     failed = true;

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_05.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_05.js
@@ -5,17 +5,17 @@
 // Test that the HeapAnalyses{Client,Worker} can take censuses and return
 // a CensusTreeNode.
 
 const BREAKDOWN = {
   by: "internalType",
   then: { by: "count", count: true, bytes: true }
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const { report } = await client.takeCensus(snapshotFilePath, {
     breakdown: BREAKDOWN

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_06.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_06.js
@@ -10,17 +10,17 @@ const BREAKDOWN = {
   then: {
     by: "allocationStack",
     then: { by: "count", count: true, bytes: true },
     noStack: { by: "count", count: true, bytes: true }
   },
   other: { by: "count", count: true, bytes: true }
 };
 
-add_task(async function() {
+add_task(async function () {
   const g = newGlobal();
   const dbg = new Debugger(g);
 
   // 5 allocation markers with no stack.
   g.eval(`
          this.markers = [];
          for (var i = 0; i < 5; i++) {
            markers.push(allocationMarker());

--- a/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_07.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_HeapAnalyses_takeCensus_07.js
@@ -21,17 +21,17 @@ const BREAKDOWN = {
     then: { by: "count", count: true, bytes: true },
   },
   other: {
     by: "internalType",
     then: { by: "count", count: true, bytes: true },
   },
 };
 
-add_task(async function() {
+add_task(async function () {
   const client = new HeapAnalysesClient();
 
   const snapshotFilePath = saveNewHeapSnapshot();
   await client.readHeapSnapshot(snapshotFilePath);
   ok(true, "Should have read the heap snapshot");
 
   const { report } = await client.takeCensus(snapshotFilePath, {
     breakdown: BREAKDOWN

--- a/devtools/shared/heapsnapshot/tests/unit/test_ReadHeapSnapshot_worker.js
+++ b/devtools/shared/heapsnapshot/tests/unit/test_ReadHeapSnapshot_worker.js
@@ -1,14 +1,14 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 // Test that we can read core dumps into HeapSnapshot instances in a worker.
 // eslint-disable-next-line
-add_task(async function() {
+add_task(async function () {
   const worker = new ChromeWorker("resource://test/heap-snapshot-worker.js");
   worker.postMessage({});
 
   let assertionCount = 0;
   worker.onmessage = e => {
     if (e.data.type !== "assertion") {
       return;
     }

--- a/devtools/shared/qrcode/tests/mochitest/test_decode.html
+++ b/devtools/shared/qrcode/tests/mochitest/test_decode.html
@@ -22,17 +22,17 @@ window.onload = function() {
     "/4yPqcvtD6OctNqLs968+w+G4gKU5nkaKKquLuW+QVy2tAkDTj3rfQts8CRDko" +
     "+HPPoYRUgy9YsyldDm44mLWhHYZM6W7WaDqyCRGkZDySxpRGw2sqvLt1q5w/fo" +
     "XyE6vnUQOJUHBlinMGh046V1F5PDqNcoqcgBOWKBKbK2N+aY+Ih49VkmqMcl2l" +
     "dkhZUK1umE6jZXJ2ZJaujZaRqH4bpb2uZrJxvIt4Ebe9qoYYrJOsw8apz2bCut" +
     "m9kqDcw52uuImyr5Oh1KXH1jrn2anuunywtODU/o2c6teceW39ZcLFg/fNMo1b" +
     "t3jVw2dwTPwJq1KYG3gAklCgu37yGxeScYKyiCc+7DR34hPVQiuQ7UhJMagyEb" +
     "lymmzJk0a9q8iTOnzp0NCgAAOw==";
 
-  (async function() {
+  (async function () {
     let result = await QR.decodeFromURI(testImage);
     is(result, "HELLO", "Decoded data URI result matches");
     let canvas = await drawToCanvas(testImage);
     result = QR.decodeFromCanvas(canvas);
     is(result, "HELLO", "Decoded canvas result matches");
   })().then(SimpleTest.finish, ok.bind(null, false));
 
   function drawToCanvas(src) {

--- a/devtools/shared/security/socket.js
+++ b/devtools/shared/security/socket.js
@@ -70,17 +70,17 @@ var DebuggerSocket = {};
  * @param authenticator Authenticator (optional)
  *        |Authenticator| instance matching the mode in use by the server.
  *        Defaults to a PROMPT instance if not supplied.
  * @param cert object (optional)
  *        The server's cert details.  Used with OOB_CERT authentication.
  * @return promise
  *         Resolved to a DebuggerTransport instance.
  */
-DebuggerSocket.connect = async function(settings) {
+DebuggerSocket.connect = async function (settings) {
   // Default to PROMPT |Authenticator| instance if not supplied
   if (!settings.authenticator) {
     settings.authenticator = new (Authenticators.get().Client)();
   }
   _validateSettings(settings);
   let { host, port, encryption, authenticator, cert } = settings;
   let transport = await _getTransport(settings);
   await authenticator.authenticate({
@@ -122,17 +122,17 @@ function _validateSettings(settings) {
  *        |Authenticator| instance matching the mode in use by the server.
  *        Defaults to a PROMPT instance if not supplied.
  * @param cert object (optional)
  *        The server's cert details.  Used with OOB_CERT authentication.
  * @return transport DebuggerTransport
  *         A possible DevTools transport (if connection succeeded and streams
  *         are actually alive and working)
  */
-var _getTransport = async function(settings) {
+var _getTransport = async function (settings) {
   let { host, port, encryption, webSocket } = settings;
 
   if (webSocket) {
     // Establish a connection and wait until the WebSocket is ready to send and receive
     let socket = await new Promise((resolve, reject) => {
       let s = new WebSocket(`ws://${host}:${port}`);
       s.onopen = () => resolve(s);
       s.onerror = err => reject(err);
@@ -184,17 +184,17 @@ var _getTransport = async function(setti
  * @return transport DebuggerTransport
  *         A possible DevTools transport (if connection succeeded and streams
  *         are actually alive and working)
  * @return certError boolean
  *         Flag noting if cert trouble caused the streams to fail
  * @return s nsISocketTransport
  *         Underlying socket transport, in case more details are needed.
  */
-var _attemptTransport = async function(settings) {
+var _attemptTransport = async function (settings) {
   let { authenticator } = settings;
   // _attemptConnect only opens the streams.  Any failures at that stage
   // aborts the connection process immedidately.
   let { s, input, output } = await _attemptConnect(settings);
 
   // Check if the input stream is alive.  If encryption is enabled, we need to
   // watch out for cert errors by testing the input stream.
   let alive, certError;
@@ -242,17 +242,17 @@ var _attemptTransport = async function(s
  * fail later when the streams are actually used.
  * @return s nsISocketTransport
  *         Underlying socket transport, in case more details are needed.
  * @return input nsIAsyncInputStream
  *         The socket's input stream.
  * @return output nsIAsyncOutputStream
  *         The socket's output stream.
  */
-var _attemptConnect = async function({ host, port, encryption }) {
+var _attemptConnect = async function ({ host, port, encryption }) {
   let s;
   if (encryption) {
     s = socketTransportService.createTransport(["ssl"], 1, host, port, null);
   } else {
     s = socketTransportService.createTransport(null, 0, host, port, null);
   }
   // By default the CONNECT socket timeout is very long, 65535 seconds,
   // so that if we race to be in CONNECT state while the server socket is still
@@ -425,17 +425,17 @@ SocketListener.prototype = {
 
     let flags = Ci.nsIServerSocket.KeepWhenOffline;
     // A preference setting can force binding on the loopback interface.
     if (Services.prefs.getBoolPref("devtools.debugger.force-local")) {
       flags |= Ci.nsIServerSocket.LoopbackOnly;
     }
 
     let self = this;
-    return (async function() {
+    return (async function () {
       let backlog = 4;
       self._socket = self._createSocketInstance();
       if (self.isPortBased) {
         let port = Number(self.portOrPath);
         self._socket.initSpecialConnection(port, flags, backlog);
       } else {
         let file = nsFile(self.portOrPath);
         if (file.exists()) {
@@ -624,17 +624,17 @@ ServerSocketConnection.prototype = {
   /**
    * This is the main authentication workflow.  If any pieces reject a promise,
    * the connection is denied.  If the entire process resolves successfully,
    * the connection is finally handed off to the |DebuggerServer|.
    */
   _handle() {
     dumpn("Debugging connection starting authentication on " + this.address);
     let self = this;
-    (async function() {
+    (async function () {
       self._listenForTLSHandshake();
       await self._createTransport();
       await self._awaitTLSHandshake();
       await self._authenticate();
     })().then(() => this.allow()).catch(e => this.deny(e));
   },
 
   /**

--- a/devtools/shared/security/tests/chrome/test_websocket-transport.html
+++ b/devtools/shared/security/tests/chrome/test_websocket-transport.html
@@ -20,17 +20,17 @@ window.onload = function () {
   Services.prefs.setBoolPref("devtools.debugger.remote-enabled", true);
   Services.prefs.setBoolPref("devtools.debugger.prompt-connection", false);
 
   SimpleTest.registerCleanupFunction(() => {
     Services.prefs.clearUserPref("devtools.debugger.remote-enabled");
     Services.prefs.clearUserPref("devtools.debugger.prompt-connection");
   });
 
-  add_task(async function() {
+  add_task(async function () {
     DebuggerServer.init();
     DebuggerServer.registerAllActors();
 
     is(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
     let listener = DebuggerServer.createListener();
     ok(listener, "Socket listener created");
     listener.portOrPath = -1;

--- a/devtools/shared/security/tests/unit/test_encryption.js
+++ b/devtools/shared/security/tests/unit/test_encryption.js
@@ -11,22 +11,22 @@ function run_test() {
   Cc["@mozilla.org/psm;1"].getService(Ci.nsISupports);
   run_next_test();
 }
 
 function connectClient(client) {
   return client.connect(() => client.listTabs());
 }
 
-add_task(async function() {
+add_task(async function () {
   initTestDebuggerServer();
 });
 
 // Client w/ encryption connects successfully to server w/ encryption
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   let AuthenticatorType = DebuggerServer.Authenticators.get("PROMPT");
   let authenticator = new AuthenticatorType.Server();
   authenticator.allowConnection = () => {
     return DebuggerServer.AuthenticationResult.ALLOW;
   };
 
@@ -63,17 +63,17 @@ add_task(async function() {
 
   client.removeListener("closed", onUnexpectedClose);
   transport.close();
   listener.close();
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 });
 
 // Client w/o encryption fails to connect to server w/ encryption
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   let AuthenticatorType = DebuggerServer.Authenticators.get("PROMPT");
   let authenticator = new AuthenticatorType.Server();
   authenticator.allowConnection = () => {
     return DebuggerServer.AuthenticationResult.ALLOW;
   };
 
@@ -96,11 +96,11 @@ add_task(async function() {
     listener.close();
     equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
     return;
   }
 
   do_throw("Connection unexpectedly succeeded");
 });
 
-add_task(async function() {
+add_task(async function () {
   DebuggerServer.destroy();
 });

--- a/devtools/shared/security/tests/unit/test_oob_cert_auth.js
+++ b/devtools/shared/security/tests/unit/test_oob_cert_auth.js
@@ -16,22 +16,22 @@ function run_test() {
 }
 
 function connectClient(client) {
   return client.connect(() => {
     return client.listTabs();
   });
 }
 
-add_task(async function() {
+add_task(async function () {
   initTestDebuggerServer();
 });
 
 // Client w/ OOB_CERT auth connects successfully to server w/ OOB_CERT auth
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   // Grab our cert, instead of relying on a discovery advertisement
   let serverCert = await cert.local.getOrCreate();
 
   let oobData = defer();
   let AuthenticatorType = DebuggerServer.Authenticators.get("OOB_CERT");
   let serverAuth = new AuthenticatorType.Server();
@@ -85,17 +85,17 @@ add_task(async function() {
 
   client.removeListener("closed", onUnexpectedClose);
   transport.close();
   listener.close();
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 });
 
 // Client w/o OOB_CERT auth fails to connect to server w/ OOB_CERT auth
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   let oobData = defer();
   let AuthenticatorType = DebuggerServer.Authenticators.get("OOB_CERT");
   let serverAuth = new AuthenticatorType.Server();
   serverAuth.allowConnection = () => {
     return DebuggerServer.AuthenticationResult.ALLOW;
   };
@@ -146,17 +146,17 @@ add_task(async function() {
     equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
     return;
   }
 
   do_throw("Connection unexpectedly succeeded");
 });
 
 // Client w/ invalid K value fails to connect
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   // Grab our cert, instead of relying on a discovery advertisement
   let serverCert = await cert.local.getOrCreate();
 
   let oobData = defer();
   let AuthenticatorType = DebuggerServer.Authenticators.get("OOB_CERT");
   let serverAuth = new AuthenticatorType.Server();
@@ -201,17 +201,17 @@ add_task(async function() {
     equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
     return;
   }
 
   do_throw("Connection unexpectedly succeeded");
 });
 
 // Client w/ invalid cert hash fails to connect
-add_task(async function() {
+add_task(async function () {
   equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
 
   // Grab our cert, instead of relying on a discovery advertisement
   let serverCert = await cert.local.getOrCreate();
 
   let oobData = defer();
   let AuthenticatorType = DebuggerServer.Authenticators.get("OOB_CERT");
   let serverAuth = new AuthenticatorType.Server();
@@ -255,11 +255,11 @@ add_task(async function() {
     listener.close();
     equal(DebuggerServer.listeningSockets, 0, "0 listening sockets");
     return;
   }
 
   do_throw("Connection unexpectedly succeeded");
 });
 
-add_task(async function() {
+add_task(async function () {
   DebuggerServer.destroy();
 });

--- a/devtools/shared/tests/browser/browser_async_storage.js
+++ b/devtools/shared/tests/browser/browser_async_storage.js
@@ -3,55 +3,55 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Test the basic functionality of async-storage.
 // Adapted from https://github.com/mozilla-b2g/gaia/blob/f09993563fb5fec4393eb71816ce76cb00463190/apps/sharedtest/test/unit/async_storage_test.js.
 
 const asyncStorage = require("devtools/shared/async-storage");
-add_task(async function() {
+add_task(async function () {
   is(typeof asyncStorage.length, "function", "API exists.");
   is(typeof asyncStorage.key, "function", "API exists.");
   is(typeof asyncStorage.getItem, "function", "API exists.");
   is(typeof asyncStorage.setItem, "function", "API exists.");
   is(typeof asyncStorage.removeItem, "function", "API exists.");
   is(typeof asyncStorage.clear, "function", "API exists.");
 });
 
-add_task(async function() {
+add_task(async function () {
   await asyncStorage.setItem("foo", "bar");
   let value = await asyncStorage.getItem("foo");
   is(value, "bar", "value is correct");
   await asyncStorage.setItem("foo", "overwritten");
   value = await asyncStorage.getItem("foo");
   is(value, "overwritten", "value is correct");
   await asyncStorage.removeItem("foo");
   value = await asyncStorage.getItem("foo");
   is(value, null, "value is correct");
 });
 
-add_task(async function() {
+add_task(async function () {
   let object = {
     x: 1,
     y: "foo",
     z: true
   };
 
   await asyncStorage.setItem("myobj", object);
   let value = await asyncStorage.getItem("myobj");
   is(object.x, value.x, "value is correct");
   is(object.y, value.y, "value is correct");
   is(object.z, value.z, "value is correct");
   await asyncStorage.removeItem("myobj");
   value = await asyncStorage.getItem("myobj");
   is(value, null, "value is correct");
 });
 
-add_task(async function() {
+add_task(async function () {
   await asyncStorage.clear();
   let len = await asyncStorage.length();
   is(len, 0, "length is correct");
   await asyncStorage.setItem("key1", "value1");
   len = await asyncStorage.length();
   is(len, 1, "length is correct");
   await asyncStorage.setItem("key2", "value2");
   len = await asyncStorage.length();

--- a/devtools/shared/tests/unit/test_defer.js
+++ b/devtools/shared/tests/unit/test_defer.js
@@ -12,17 +12,17 @@ function testResolve() {
 }
 
 function testReject() {
   const deferred = defer();
   deferred.reject("error");
   return deferred.promise;
 }
 
-add_task(async function() {
+add_task(async function () {
   const success = await testResolve();
   equal(success, "success");
 
   let error;
   try {
     await testReject();
   } catch (e) {
     error = e;

--- a/devtools/shared/tests/unit/test_executeSoon.js
+++ b/devtools/shared/tests/unit/test_executeSoon.js
@@ -16,17 +16,17 @@ var defer = require("devtools/shared/def
 var asyncStackEnabled =
   Services.prefs.getBoolPref("javascript.options.asyncstack");
 
 registerCleanupFunction(() => {
   Services.prefs.setBoolPref("javascript.options.asyncstack",
                              asyncStackEnabled);
 });
 
-add_task(async function() {
+add_task(async function () {
   Services.prefs.setBoolPref("javascript.options.asyncstack", true);
 
   await waitForTick();
 
   let stack = Components.stack;
   while (stack) {
     info(stack.name);
     if (stack.name == "waitForTick") {

--- a/devtools/shared/tests/unit/test_fetch-bom.js
+++ b/devtools/shared/tests/unit/test_fetch-bom.js
@@ -56,17 +56,17 @@ server.start(-1);
 
 const port = server.identity.primaryPort;
 const serverURL = "http://localhost:" + port;
 
 registerCleanupFunction(() => {
   return new Promise(resolve => server.stop(resolve));
 });
 
-add_task(async function() {
+add_task(async function () {
   await test_one(serverURL + "/u8", "UTF-8");
   await test_one(serverURL + "/u16be", "UTF-16BE");
   await test_one(serverURL + "/u16le", "UTF-16LE");
 });
 
 function* test_one(url, encoding) {
   // Be sure to set the encoding to something that will yield an
   // invalid result if BOM sniffing is not done.

--- a/devtools/shared/transport/tests/unit/head_dbg.js
+++ b/devtools/shared/transport/tests/unit/head_dbg.js
@@ -125,17 +125,17 @@ function writeTestTempFile(fileName, con
     } while (content.length > 0);
   } finally {
     stream.close();
   }
 }
 
 /** * Transport Factories ***/
 
-var socket_transport = async function() {
+var socket_transport = async function () {
   if (!DebuggerServer.listeningSockets) {
     let AuthenticatorType = DebuggerServer.Authenticators.get("PROMPT");
     let authenticator = new AuthenticatorType.Server();
     authenticator.allowConnection = () => {
       return DebuggerServer.AuthenticationResult.ALLOW;
     };
     let debuggerListener = DebuggerServer.createListener();
     debuggerListener.portOrPath = -1;

--- a/devtools/shared/transport/tests/unit/test_bulk_error.js
+++ b/devtools/shared/transport/tests/unit/test_bulk_error.js
@@ -2,17 +2,17 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 function run_test() {
   initTestDebuggerServer();
   add_test_bulk_actor();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_string_error(socket_transport, json_reply);
     await test_string_error(local_transport, json_reply);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 
@@ -39,17 +39,17 @@ TestBulkActor.prototype.requestTypes = {
 };
 
 function add_test_bulk_actor() {
   DebuggerServer.addGlobalActor(TestBulkActor);
 }
 
 /** * Tests ***/
 
-var test_string_error = async function(transportFactory, onReady) {
+var test_string_error = async function (transportFactory, onReady) {
   let transport = await transportFactory();
 
   let client = new DebuggerClient(transport);
   return client.connect().then(([app, traits]) => {
     Assert.equal(traits.bulk, true);
     return client.listTabs();
   }).then(response => {
     return onReady(client, response);

--- a/devtools/shared/transport/tests/unit/test_client_server_bulk.js
+++ b/devtools/shared/transport/tests/unit/test_client_server_bulk.js
@@ -5,17 +5,17 @@
 
 var { FileUtils } = ChromeUtils.import("resource://gre/modules/FileUtils.jsm", {});
 var Pipe = CC("@mozilla.org/pipe;1", "nsIPipe", "init");
 
 function run_test() {
   initTestDebuggerServer();
   add_test_bulk_actor();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_bulk_request_cs(socket_transport, "jsonReply", "json");
     await test_bulk_request_cs(local_transport, "jsonReply", "json");
     await test_bulk_request_cs(socket_transport, "bulkEcho", "bulk");
     await test_bulk_request_cs(local_transport, "bulkEcho", "bulk");
     await test_json_request_cs(socket_transport, "bulkReply", "bulk");
     await test_json_request_cs(local_transport, "bulkReply", "bulk");
     DebuggerServer.destroy();
   });
@@ -128,17 +128,17 @@ var replyHandlers = {
     });
     return replyDeferred.promise;
   }
 
 };
 
 /** * Tests ***/
 
-var test_bulk_request_cs = async function(transportFactory, actorType, replyType) {
+var test_bulk_request_cs = async function (transportFactory, actorType, replyType) {
   // Ensure test files are not present from a failed run
   cleanup_files();
   writeTestTempFile("bulk-input", really_long());
 
   let clientDeferred = defer();
   let serverDeferred = defer();
   let bulkCopyDeferred = defer();
 
@@ -187,17 +187,17 @@ var test_bulk_request_cs = async functio
 
   return promise.all([
     clientDeferred.promise,
     bulkCopyDeferred.promise,
     serverDeferred.promise
   ]);
 };
 
-var test_json_request_cs = async function(transportFactory, actorType, replyType) {
+var test_json_request_cs = async function (transportFactory, actorType, replyType) {
   // Ensure test files are not present from a failed run
   cleanup_files();
   writeTestTempFile("bulk-input", really_long());
 
   let clientDeferred = defer();
   let serverDeferred = defer();
 
   let transport = await transportFactory();

--- a/devtools/shared/transport/tests/unit/test_dbgsocket_connection_drop.js
+++ b/devtools/shared/transport/tests/unit/test_dbgsocket_connection_drop.js
@@ -39,17 +39,17 @@ function test_socket_conn_drops_after_to
   // The packet header is currently limited to no more than 200 bytes
   let rawPacket = "4305724038957487634549823475894325";
   for (let i = 0; i < 8; i++) {
     rawPacket += rawPacket;
   }
   return test_helper(rawPacket + ":");
 }
 
-var test_helper = async function(payload) {
+var test_helper = async function (payload) {
   let AuthenticatorType = DebuggerServer.Authenticators.get("PROMPT");
   let authenticator = new AuthenticatorType.Server();
   authenticator.allowConnection = () => {
     return DebuggerServer.AuthenticationResult.ALLOW;
   };
 
   let listener = DebuggerServer.createListener();
   listener.portOrPath = -1;

--- a/devtools/shared/transport/tests/unit/test_delimited_read.js
+++ b/devtools/shared/transport/tests/unit/test_delimited_read.js
@@ -3,17 +3,17 @@
 "use strict";
 
 const StreamUtils = require("devtools/shared/transport/stream-utils");
 
 const StringInputStream = CC("@mozilla.org/io/string-input-stream;1",
                              "nsIStringInputStream", "setData");
 
 function run_test() {
-  add_task(async function() {
+  add_task(async function () {
     await test_delimited_read("0123:", "0123:");
     await test_delimited_read("0123:4567:", "0123:");
     await test_delimited_read("012345678901:", "0123456789");
     await test_delimited_read("0123/0123", "0123/0123");
   });
 
   run_next_test();
 }

--- a/devtools/shared/transport/tests/unit/test_no_bulk.js
+++ b/devtools/shared/transport/tests/unit/test_no_bulk.js
@@ -3,28 +3,28 @@
 
 "use strict";
 
 function run_test() {
   DebuggerServer.registerModule("xpcshell-test/testactors-no-bulk");
   // Allow incoming connections.
   DebuggerServer.init();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_bulk_send_error(socket_transport);
     await test_bulk_send_error(local_transport);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 
 /** * Tests ***/
 
-var test_bulk_send_error = async function(transportFactory) {
+var test_bulk_send_error = async function (transportFactory) {
   let transport = await transportFactory();
 
   let client = new DebuggerClient(transport);
   return client.connect().then(([app, traits]) => {
     Assert.ok(!traits.bulk);
 
     try {
       client.startBulkRequest();

--- a/devtools/shared/transport/tests/unit/test_queue.js
+++ b/devtools/shared/transport/tests/unit/test_queue.js
@@ -8,28 +8,28 @@
  * packets are scheduled simultaneously.
  */
 
 var { FileUtils } = ChromeUtils.import("resource://gre/modules/FileUtils.jsm", {});
 
 function run_test() {
   initTestDebuggerServer();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_transport(socket_transport);
     await test_transport(local_transport);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 
 /** * Tests ***/
 
-var test_transport = async function(transportFactory) {
+var test_transport = async function (transportFactory) {
   let clientDeferred = defer();
   let serverDeferred = defer();
 
   // Ensure test files are not present from a failed run
   cleanup_files();
   let reallyLong = really_long();
   writeTestTempFile("bulk-input", reallyLong);
 

--- a/devtools/shared/transport/tests/unit/test_transport_bulk.js
+++ b/devtools/shared/transport/tests/unit/test_transport_bulk.js
@@ -3,31 +3,31 @@
 
 "use strict";
 
 var { FileUtils } = ChromeUtils.import("resource://gre/modules/FileUtils.jsm", {});
 
 function run_test() {
   initTestDebuggerServer();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_bulk_transfer_transport(socket_transport);
     await test_bulk_transfer_transport(local_transport);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 
 /** * Tests ***/
 
 /**
  * This tests a one-way bulk transfer at the transport layer.
  */
-var test_bulk_transfer_transport = async function(transportFactory) {
+var test_bulk_transfer_transport = async function (transportFactory) {
   info("Starting bulk transfer test at " + new Date().toTimeString());
 
   let clientDeferred = defer();
   let serverDeferred = defer();
 
   // Ensure test files are not present from a failed run
   cleanup_files();
   let reallyLong = really_long();

--- a/devtools/shared/transport/tests/unit/test_transport_events.js
+++ b/devtools/shared/transport/tests/unit/test_transport_events.js
@@ -1,17 +1,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 function run_test() {
   initTestDebuggerServer();
 
-  add_task(async function() {
+  add_task(async function () {
     await test_transport_events("socket", socket_transport);
     await test_transport_events("local", local_transport);
     DebuggerServer.destroy();
   });
 
   run_next_test();
 }
 

--- a/devtools/shared/webconsole/test/common.js
+++ b/devtools/shared/webconsole/test/common.js
@@ -47,17 +47,17 @@ function attachConsole(listeners, callba
 }
 function attachConsoleToTab(listeners, callback) {
   _attachConsole(listeners, callback, true);
 }
 function attachConsoleToWorker(listeners, callback) {
   _attachConsole(listeners, callback, true, true);
 }
 
-var _attachConsole = async function(
+var _attachConsole = async function (
   listeners, callback, attachToTab, attachToWorker
 ) {
   function _onAttachConsole(state, response, webConsoleClient) {
     if (response.error) {
       console.error("attachConsole failed: " + response.error + " " +
                     response.message);
     }
 

--- a/devtools/shared/webconsole/test/test_commands_other.html
+++ b/devtools/shared/webconsole/test/test_commands_other.html
@@ -67,17 +67,17 @@ function testEnd() {
   gWin.close();
   gWin = null;
   closeDebugger(gState, function() {
     gState = null;
     SimpleTest.finish();
   });
 }
 
-let load = async function() {
+let load = async function () {
   removeEventListener("load", load);
 
   await new Promise(resolve => {
     SpecialPowers.pushPrefEnv({"set": [
       ["security.data_uri.unique_opaque_origin", false],
     ]}, resolve);
   });
 

--- a/devtools/shared/webconsole/test/test_console_serviceworker.html
+++ b/devtools/shared/webconsole/test/test_console_serviceworker.html
@@ -95,31 +95,31 @@ let expectedConsoleCalls = [
     {
       level: "log",
       filename: /helper_serviceworker/,
       arguments: ['fetch event: ' + SCOPE_FRAME_URL2],
     },
 ];
 let consoleCalls = [];
 
-let startTest = async function() {
+let startTest = async function () {
   removeEventListener("load", startTest);
 
   await new Promise(resolve => {
     SpecialPowers.pushPrefEnv({"set": [
       ["dom.serviceWorkers.enabled", true],
       ["devtools.webconsole.filter.serviceworkers", true]
     ]}, resolve);
   });
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 };
 addEventListener("load", startTest);
 
-let onAttach = async function(state, response) {
+let onAttach = async function (state, response) {
   onConsoleAPICall = onConsoleAPICall.bind(null, state);
   state.dbgClient.addListener("consoleAPICall", onConsoleAPICall);
 
   let currentFrame;
   try {
     // First, we need a frame from which to register our script.  This
     // will not trigger any console calls.
     info("Loading a non-scope frame from which to register a service worker.");

--- a/devtools/shared/webconsole/test/test_console_serviceworker_cached.html
+++ b/devtools/shared/webconsole/test/test_console_serviceworker_cached.html
@@ -39,17 +39,17 @@ let firstTabExpectedCalls = [
 let secondTabExpectedCalls = [
   {
     level: "log",
     filename: /helper_serviceworker/,
     arguments: ['fetch event: ' + FRAME_URL],
   }
 ];
 
-let startTest = async function() {
+let startTest = async function () {
   removeEventListener("load", startTest);
 
   await new Promise(resolve => {
     SpecialPowers.pushPrefEnv({"set": [
       ["dom.serviceWorkers.enabled", true],
       ["devtools.webconsole.filter.serviceworkers", true]
     ]}, resolve);
   });

--- a/devtools/shared/webconsole/test/test_console_worker.html
+++ b/devtools/shared/webconsole/test/test_console_worker.html
@@ -24,46 +24,46 @@ let expectedCachedConsoleCalls = [
 
 let expectedConsoleAPICalls = [
     {
       level: "log",
       arguments: ['Log was requested from worker'],
     },
 ];
 
-window.onload = async function() {
+window.onload = async function () {
   let {state,response} = await new Promise(resolve => {
     attachConsoleToWorker(["ConsoleAPI"], (state, response) => {
       resolve({state,response})
     });
   });
 
   await testCachedMessages(state);
   await testConsoleAPI(state);
 
   closeDebugger(state, function() {
     SimpleTest.finish();
   });
 };
 
-let testCachedMessages = async function(state) {
+let testCachedMessages = async function (state) {
   info("testCachedMessages entered");
   return new Promise(resolve => {
     let onCachedConsoleAPI = (response) => {
       let consoleCalls = response.messages;
 
       info('Received cached response. Checking console calls.');
       checkConsoleAPICalls(consoleCalls, expectedCachedConsoleCalls);
       resolve();
     };
     state.client.getCachedMessages(["ConsoleAPI"], onCachedConsoleAPI);
   })
 };
 
-let testConsoleAPI = async function(state) {
+let testConsoleAPI = async function (state) {
   info("testConsoleAPI entered");
   return new Promise(resolve => {
     let onConsoleAPICall = (type, packet) => {
       info("received message level: " + packet.message.level);
       is(packet.from, state.actor, "console API call actor");
       checkConsoleAPICalls([packet.message], expectedConsoleAPICalls);
       state.dbgClient.removeListener("consoleAPICall", onConsoleAPICall);
       resolve();

--- a/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
+++ b/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
@@ -35,17 +35,17 @@ let runningInTab = true;
 function startTest({worker}) {
   if (worker) {
     attachConsoleToWorker(["PageError"], onAttach);
   } else {
     attachConsoleToTab(["PageError"], onAttach);
   }
 };
 
-let onAttach = async function(aState, response) {
+let onAttach = async function (aState, response) {
   gState = aState;
 
   let longStrLength = DebuggerServer.LONG_STRING_LENGTH;
 
   // Set up the global variables needed to test autocompletion
   // in the target.
   let script = `
     // This is for workers so autocomplete acts the same

--- a/devtools/shared/webconsole/test/test_jsterm_last_result.html
+++ b/devtools/shared/webconsole/test/test_jsterm_last_result.html
@@ -33,41 +33,41 @@ function startTest()
   removeEventListener("load", startTest);
   attachConsoleToTab([], state => {
     gState = state;
     let tests = [checkUndefinedResult,checkAdditionResult,checkObjectResult];
     runTests(tests, testEnd);
   });
 }
 
-let checkUndefinedResult = async function() {
+let checkUndefinedResult = async function () {
   info ("$_ returns undefined if nothing has evaluated yet");
   let response = await evaluateJS("$_");
   basicResultCheck(response, "$_", undefined);
   nextTest();
 };
 
-let checkAdditionResult = async function() {
+let checkAdditionResult = async function () {
   info ("$_ returns last value and performs basic arithmetic");
   let response = await evaluateJS("2+2");
   basicResultCheck(response, "2+2", 4);
 
   response = await evaluateJS("$_");
   basicResultCheck(response, "$_", 4);
 
   response = await evaluateJS("$_ + 2");
   basicResultCheck(response, "$_ + 2", 6);
 
   response = await evaluateJS("$_ + 4");
   basicResultCheck(response, "$_ + 4", 10);
 
   nextTest();
 };
 
-let checkObjectResult = async function() {
+let checkObjectResult = async function () {
   info ("$_ has correct references to objects");
 
   let response = await evaluateJS("var foo = {bar:1}; foo;");
   basicResultCheck(response, "var foo = {bar:1}; foo;", {
     type: "object",
     class: "Object",
     actor: /[a-z]/,
   });

--- a/devtools/shared/webconsole/test/test_jsterm_queryselector.html
+++ b/devtools/shared/webconsole/test/test_jsterm_queryselector.html
@@ -36,64 +36,64 @@ function startTest() {
       checkQuerySelectorAllNotExist,
       checkQuerySelectorException,
       checkQuerySelectorAllException
     ];
     runTests(tests, testEnd);
   });
 }
 
-let setupWindow = async function() {
+let setupWindow = async function () {
   info ("Shimming window functions for the content privileged tab");
   await evaluateJS("document.querySelector = function() { throw 'should not call qS'; }");
   await evaluateJS("document.querySelectorAll = function() { throw 'should not call qSA'; }");
   nextTest();
 };
 
-let checkQuerySelector = async function() {
+let checkQuerySelector = async function () {
   info ("$ returns an DOMNode");
   let response = await evaluateJS("$('body')");
   basicResultCheck(response, "$('body')", {
     type: "object",
     class: "HTMLBodyElement",
     preview: {
       kind: "DOMNode",
       nodeName: "body"
     }
   });
   nextTest();
 };
 
-let checkQuerySelectorAll = async function() {
+let checkQuerySelectorAll = async function () {
   info ("$$ returns an array");
   let response = await evaluateJS("$$('body')");
   basicResultCheck(response, "$$('body')", {
     type: "object",
     class: "Array",
     preview: {
       length: 1
     }
   });
   nextTest();
 };
 
-let checkQuerySelectorAllNotExist = async function() {
+let checkQuerySelectorAllNotExist = async function () {
   info ("$$ returns an array even if query yields no results");
   let response = await evaluateJS("$$('foobar')");
   basicResultCheck(response, "$$('foobar')", {
     type: "object",
     class: "Array",
     preview: {
       length: 0
     }
   });
   nextTest();
 };
 
-let checkQuerySelectorException = async function() {
+let checkQuerySelectorException = async function () {
   info ("$ returns an exception if an invalid selector was provided");
   let response = await evaluateJS("$(':foo')");
   checkObject(response, {
     input: "$(':foo')",
     exceptionMessage: "SyntaxError: ':foo' is not a valid selector",
     exception: {
       type: "object",
       class: "DOMException",
@@ -102,17 +102,17 @@ let checkQuerySelectorException = async 
         name: "SyntaxError",
         message: "':foo' is not a valid selector"
       }
     }
   });
   nextTest();
 };
 
-let checkQuerySelectorAllException = async function() {
+let checkQuerySelectorAllException = async function () {
   info ("$$ returns an exception if an invalid selector was provided");
   let response = await evaluateJS("$$(':foo')");
   checkObject(response, {
     input: "$$(':foo')",
     exceptionMessage: "SyntaxError: ':foo' is not a valid selector",
     exception: {
       type: "object",
       class: "DOMException",
@@ -140,17 +140,17 @@ function testEnd() {
   gWin.close();
   gWin = null;
   closeDebugger(gState, function() {
     gState = null;
     SimpleTest.finish();
   });
 }
 
-let load = async function() {
+let load = async function () {
   removeEventListener("load", load);
 
   await new Promise(resolve => {
     SpecialPowers.pushPrefEnv({"set": [
       ["security.data_uri.unique_opaque_origin", false],
     ]}, resolve);
   });
 

--- a/devtools/shared/webconsole/test/unit/test_throttle.js
+++ b/devtools/shared/webconsole/test/unit/test_throttle.js
@@ -66,17 +66,17 @@ TestChannel.prototype = {
 
   setNewListener: function (listener) {
     this.listener = listener;
     this.state = "listener";
     return this.testListener;
   },
 };
 
-add_task(async function() {
+add_task(async function () {
   let throttler = new NetworkThrottleManager({
     latencyMean: 1,
     latencyMax: 1,
     downloadBPSMean: 500,
     downloadBPSMax: 500,
     uploadBPSMean: 500,
     uploadBPSMax: 500,
   });

--- a/devtools/shared/worker/tests/browser/browser_worker-01.js
+++ b/devtools/shared/worker/tests/browser/browser_worker-01.js
@@ -15,17 +15,17 @@ const WORKER_DATA = (function () {
   for (let i = 0; i < count; i++) {
     timestamps.push(i);
   }
   return timestamps;
 })();
 const INTERVAL = 100;
 const DURATION = 1000;
 
-add_task(async function() {
+add_task(async function () {
   // Test both CJS and JSM versions
 
   await testWorker("JSM", () => ChromeUtils.import("resource://devtools/shared/worker/worker.js", {}));
   await testWorker("CommonJS", () => require("devtools/shared/worker/worker"));
 });
 
 function* testWorker(context, workerFactory) {
   let { DevToolsWorker, workerify } = workerFactory();

--- a/devtools/shared/worker/tests/browser/browser_worker-02.js
+++ b/devtools/shared/worker/tests/browser/browser_worker-02.js
@@ -4,17 +4,17 @@
 "use strict";
 
 // Tests errors are handled properly by the DevToolsWorker.
 
 const { DevToolsWorker } = require("devtools/shared/worker/worker");
 const WORKER_URL =
   "resource://devtools/client/shared/widgets/GraphsWorker.js";
 
-add_task(async function() {
+add_task(async function () {
   try {
     new DevToolsWorker("resource://i/dont/exist.js");
     ok(false, "Creating a DevToolsWorker with an invalid URL throws");
   } catch (e) {
     ok(true, "Creating a DevToolsWorker with an invalid URL throws");
   }
 
   let worker = new DevToolsWorker(WORKER_URL);

--- a/devtools/shared/worker/tests/browser/browser_worker-03.js
+++ b/devtools/shared/worker/tests/browser/browser_worker-03.js
@@ -20,17 +20,17 @@ function squarePromise(x) {
 function squareError(x) {
   return new Error("Nope");
 }
 
 function squarePromiseReject(x) {
   return new Promise((_, reject) => reject("Nope"));
 }
 
-add_task(async function() {
+add_task(async function () {
   let fn = workerify(square);
   is((await fn(5)), 25, "return primitives successful");
   fn.destroy();
 
   fn = workerify(squarePromise);
   is((await fn(5)), 25, "promise primitives successful");
   fn.destroy();