Bug 1437828 - Put spaces before parentheses in "async function()" pattern. r=jryans draft
authorAlexandre Poirot <poirot.alex@gmail.com>
Tue, 13 Feb 2018 08:04:14 -0800
changeset 754797 9d66cc0ac667d92541344b425c1067bd80cacfad
parent 754796 39053d527d45e06bce0d7c3d79fcd7b7d26b2d3b
child 754798 3a83bbdb439ade5e8e45e2b9f41874a05c8278f7
push id99001
push userbmo:poirot.alex@gmail.com
push dateWed, 14 Feb 2018 10:14:19 +0000
reviewersjryans
bugs1437828
milestone60.0a1
Bug 1437828 - Put spaces before parentheses in "async function()" pattern. r=jryans $ find devtools/server/ -type f -exec sed -i 's/async function(/async function (/g' {} \; MozReview-Commit-ID: DLDRqbv6GNH
devtools/server/actors/inspector/utils.js
devtools/server/actors/stylesheets.js
devtools/server/performance/recorder.js
devtools/server/tests/browser/browser_accessibility_node.js
devtools/server/tests/browser/browser_accessibility_node_events.js
devtools/server/tests/browser/browser_accessibility_simple.js
devtools/server/tests/browser/browser_accessibility_walker.js
devtools/server/tests/browser/browser_animation_emitMutations.js
devtools/server/tests/browser/browser_animation_getFrames.js
devtools/server/tests/browser/browser_animation_getMultipleStates.js
devtools/server/tests/browser/browser_animation_getPlayers.js
devtools/server/tests/browser/browser_animation_getProperties.js
devtools/server/tests/browser/browser_animation_getStateAfterFinished.js
devtools/server/tests/browser/browser_animation_getSubTreeAnimations.js
devtools/server/tests/browser/browser_animation_keepFinished.js
devtools/server/tests/browser/browser_animation_playPauseIframe.js
devtools/server/tests/browser/browser_animation_playPauseSeveral.js
devtools/server/tests/browser/browser_animation_playerState.js
devtools/server/tests/browser/browser_animation_reconstructState.js
devtools/server/tests/browser/browser_animation_refreshTransitions.js
devtools/server/tests/browser/browser_animation_setCurrentTime.js
devtools/server/tests/browser/browser_animation_setPlaybackRate.js
devtools/server/tests/browser/browser_animation_simple.js
devtools/server/tests/browser/browser_animation_updatedState.js
devtools/server/tests/browser/browser_layout_getGrids.js
devtools/server/tests/browser/browser_layout_simple.js
devtools/server/tests/browser/browser_markers-cycle-collection.js
devtools/server/tests/browser/browser_markers-docloading-01.js
devtools/server/tests/browser/browser_markers-docloading-02.js
devtools/server/tests/browser/browser_markers-docloading-03.js
devtools/server/tests/browser/browser_markers-gc.js
devtools/server/tests/browser/browser_markers-minor-gc.js
devtools/server/tests/browser/browser_markers-parse-html.js
devtools/server/tests/browser/browser_markers-styles.js
devtools/server/tests/browser/browser_markers-timestamp.js
devtools/server/tests/browser/browser_perf-allocation-data.js
devtools/server/tests/browser/browser_perf-profiler-01.js
devtools/server/tests/browser/browser_perf-profiler-02.js
devtools/server/tests/browser/browser_perf-profiler-03.js
devtools/server/tests/browser/browser_perf-realtime-markers.js
devtools/server/tests/browser/browser_perf-recording-actor-01.js
devtools/server/tests/browser/browser_perf-recording-actor-02.js
devtools/server/tests/browser/browser_perf-samples-01.js
devtools/server/tests/browser/browser_perf-samples-02.js
devtools/server/tests/browser/browser_register_actor.js
devtools/server/tests/browser/browser_storage_cookies-duplicate-names.js
devtools/server/tests/browser/browser_storage_dynamic_windows.js
devtools/server/tests/browser/browser_storage_listings.js
devtools/server/tests/browser/browser_storage_updates.js
devtools/server/tests/browser/browser_stylesheets_getTextEmpty.js
devtools/server/tests/browser/browser_stylesheets_nested-iframes.js
devtools/server/tests/browser/browser_timeline.js
devtools/server/tests/browser/browser_timeline_actors.js
devtools/server/tests/browser/browser_timeline_iframes.js
devtools/server/tests/browser/head.js
devtools/server/tests/browser/storage-dynamic-windows.html
devtools/server/tests/browser/storage-helpers.js
devtools/server/tests/browser/storage-listings.html
devtools/server/tests/browser/storage-secured-iframe.html
devtools/server/tests/mochitest/test_css-properties.html
devtools/server/tests/mochitest/test_inspector-dead-nodes.html
devtools/server/tests/mochitest/test_inspector-pick-color.html
devtools/server/tests/mochitest/test_inspector-resize.html
devtools/server/tests/mochitest/test_memory.html
devtools/server/tests/mochitest/test_memory_allocations_02.html
devtools/server/tests/mochitest/test_memory_allocations_03.html
devtools/server/tests/mochitest/test_memory_allocations_04.html
devtools/server/tests/mochitest/test_memory_allocations_05.html
devtools/server/tests/mochitest/test_memory_allocations_06.html
devtools/server/tests/mochitest/test_memory_allocations_07.html
devtools/server/tests/mochitest/test_memory_attach_01.html
devtools/server/tests/mochitest/test_memory_attach_02.html
devtools/server/tests/mochitest/test_memory_census.html
devtools/server/tests/mochitest/test_memory_gc_01.html
devtools/server/tests/mochitest/test_memory_gc_events.html
devtools/server/tests/mochitest/test_styles-layout.html
devtools/server/tests/mochitest/test_websocket-server.html
devtools/server/tests/mochitest/webconsole-helpers.js
devtools/server/tests/unit/head_dbg.js
devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_01.js
devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_02.js
devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_03.js
devtools/server/tests/unit/test_blackboxing-01.js
devtools/server/tests/unit/test_blackboxing-07.js
devtools/server/tests/unit/test_breakpoint-03.js
devtools/server/tests/unit/test_breakpoint-13.js
devtools/server/tests/unit/test_breakpoint-14.js
devtools/server/tests/unit/test_breakpoint-15.js
devtools/server/tests/unit/test_breakpoint-19.js
devtools/server/tests/unit/test_breakpoint-20.js
devtools/server/tests/unit/test_breakpoint-21.js
devtools/server/tests/unit/test_breakpoint-22.js
devtools/server/tests/unit/test_listsources-04.js
devtools/server/tests/unit/test_objectgrips-14.js
devtools/server/tests/unit/test_objectgrips-15.js
devtools/server/tests/unit/test_promise_state-01.js
devtools/server/tests/unit/test_promise_state-02.js
devtools/server/tests/unit/test_promise_state-03.js
devtools/server/tests/unit/test_promises_actor_attach.js
devtools/server/tests/unit/test_promises_actor_exist.js
devtools/server/tests/unit/test_promises_actor_list_promises.js
devtools/server/tests/unit/test_promises_actor_onnewpromise.js
devtools/server/tests/unit/test_promises_actor_onpromisesettled.js
devtools/server/tests/unit/test_promises_client_getdependentpromises.js
devtools/server/tests/unit/test_promises_object_creationtimestamp.js
devtools/server/tests/unit/test_promises_object_timetosettle-01.js
devtools/server/tests/unit/test_promises_object_timetosettle-02.js
devtools/server/tests/unit/test_protocolSpec.js
devtools/server/tests/unit/test_protocol_formtype.js
devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-column-with-no-offsets-at-end-of-line.js
devtools/server/tests/unit/test_setBreakpoint-on-column.js
devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
devtools/server/tests/unit/test_setBreakpoint-on-line.js
devtools/server/tests/unit/test_sourcemaps-03.js
devtools/server/tests/unit/test_sourcemaps-16.js
devtools/server/tests/unit/test_stepping-07.js
devtools/server/websocket-server.js
--- a/devtools/server/actors/inspector/utils.js
+++ b/devtools/server/actors/inspector/utils.js
@@ -186,17 +186,17 @@ function ensureImageLoaded(image, timeou
  *   size: {
  *     naturalWidth: 400,
  *     naturalHeight: 300,
  *     resized: true }
  *  }.
  *
  * If something goes wrong, the promise is rejected.
  */
-const imageToImageData = async function(node, maxDim) {
+const imageToImageData = async function (node, maxDim) {
   let { HTMLCanvasElement, HTMLImageElement } = node.ownerGlobal;
 
   let isImg = node instanceof HTMLImageElement;
   let isCanvas = node instanceof HTMLCanvasElement;
 
   if (!isImg && !isCanvas) {
     throw new Error("node is not a <canvas> or <img> element.");
   }
--- a/devtools/server/actors/stylesheets.js
+++ b/devtools/server/actors/stylesheets.js
@@ -777,17 +777,17 @@ var StyleSheetsActor = protocol.ActorCla
    *
    * @param {Window} win
    *        Window for which to add stylesheets
    *
    * @return {Promise}
    *         Promise that resolves to an array of StyleSheetActors
    */
   _addStyleSheets: function (win) {
-    return (async function() {
+    return (async function () {
       let doc = win.document;
       // We have to set this flag in order to get the
       // StyleSheetApplicableStateChanged events.  See Document.webidl.
       doc.styleSheetChangeEventsEnabled = true;
 
       let isChrome = Services.scriptSecurityManager.isSystemPrincipal(doc.nodePrincipal);
       let styleSheets =
         isChrome ? InspectorUtils.getAllStyleSheets(doc) : doc.styleSheets;
@@ -815,17 +815,17 @@ var StyleSheetsActor = protocol.ActorCla
    * @param  {Document} doc
    *         The document including the stylesheet
    * @param  {DOMStyleSheet} styleSheet
    *         Style sheet to search
    * @return {Promise}
    *         A promise that resolves with an array of StyleSheetActors
    */
   _getImported: function (doc, styleSheet) {
-    return (async function() {
+    return (async function () {
       let rules = await styleSheet.getCSSRules();
       let imported = [];
 
       for (let i = 0; i < rules.length; i++) {
         let rule = rules[i];
         if (rule.type == CSSRule.IMPORT_RULE) {
           // With the Gecko style system, the associated styleSheet may be null
           // if it has already been seen because an import cycle for the same
--- a/devtools/server/performance/recorder.js
+++ b/devtools/server/performance/recorder.js
@@ -308,17 +308,17 @@ PerformanceRecorder.prototype = {
    * @param string options.label
    * @param boolean options.realtimeMarkers
    * @return object
    *         A promise that is resolved once recording has started.
    */
   async startRecording(options) {
     let profilerStart, timelineStart, memoryStart;
 
-    profilerStart = (async function() {
+    profilerStart = (async function () {
       let data = await this._profiler.isActive();
       if (data.isActive) {
         return data;
       }
       let startData = await this._profiler.start(
         mapRecordingOptions("profiler", options)
       );
 
--- a/devtools/server/tests/browser/browser_accessibility_node.js
+++ b/devtools/server/tests/browser/browser_accessibility_node.js
@@ -1,17 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 // Checks for the AccessibleActor
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, accessibility} =
     await initAccessibilityFrontForUrl(MAIN_DOMAIN + "doc_accessibility.html");
 
   let a11yWalker = await accessibility.getWalker(walker);
   let buttonNode = await walker.querySelector(walker.rootNode, "#button");
   let accessibleFront = await a11yWalker.getAccessibleFor(buttonNode);
 
   checkA11yFront(accessibleFront, {
--- a/devtools/server/tests/browser/browser_accessibility_node_events.js
+++ b/devtools/server/tests/browser/browser_accessibility_node_events.js
@@ -1,17 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 // Checks for the AccessibleActor events
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, accessibility} =
     await initAccessibilityFrontForUrl(MAIN_DOMAIN + "doc_accessibility.html");
 
   let a11yWalker = await accessibility.getWalker(walker);
   let a11yDoc = await a11yWalker.getDocument();
   let buttonNode = await walker.querySelector(walker.rootNode, "#button");
   let accessibleFront = await a11yWalker.getAccessibleFor(buttonNode);
   let sliderNode = await walker.querySelector(walker.rootNode, "#slider");
--- a/devtools/server/tests/browser/browser_accessibility_simple.js
+++ b/devtools/server/tests/browser/browser_accessibility_simple.js
@@ -1,17 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 // Simple checks for the AccessibilityActor and AccessibleWalkerActor
 
-add_task(async function() {
+add_task(async function () {
   let {client, accessibility} = await initAccessibilityFrontForUrl(
     "data:text/html;charset=utf-8,<title>test</title><div></div>");
 
   ok(accessibility, "The AccessibilityFront was created");
   ok(accessibility.getWalker, "The getWalker method exists");
 
   let a11yWalker = await accessibility.getWalker();
   ok(a11yWalker, "The AccessibleWalkerFront was returned");
--- a/devtools/server/tests/browser/browser_accessibility_walker.js
+++ b/devtools/server/tests/browser/browser_accessibility_walker.js
@@ -1,17 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 // Checks for the AccessibleWalkerActor
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, accessibility} =
     await initAccessibilityFrontForUrl(MAIN_DOMAIN + "doc_accessibility.html");
 
   let a11yWalker = await accessibility.getWalker(walker);
   ok(a11yWalker, "The AccessibleWalkerFront was returned");
 
   let a11yDoc = await a11yWalker.getDocument();
   ok(a11yDoc, "The AccessibleFront for root doc is created");
--- a/devtools/server/tests/browser/browser_animation_emitMutations.js
+++ b/devtools/server/tests/browser/browser_animation_emitMutations.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Test that the AnimationsActor emits events about changed animations on a
 // node after getAnimationPlayersForNode was called on that node.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Retrieve a non-animated node");
   let node = await walker.querySelector(walker.rootNode, ".not-animated");
 
   info("Retrieve the animation player for the node");
   let players = await animations.getAnimationPlayersForNode(node);
--- a/devtools/server/tests/browser/browser_animation_getFrames.js
+++ b/devtools/server/tests/browser/browser_animation_getFrames.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check that the AnimationPlayerActor exposes a getFrames method that returns
 // the list of keyframes in the animation.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Get the test node and its animation front");
   let node = await walker.querySelector(walker.rootNode, ".simple-animation");
   let [player] = await animations.getAnimationPlayersForNode(node);
 
   ok(player.getFrames, "The front has the getFrames method");
--- a/devtools/server/tests/browser/browser_animation_getMultipleStates.js
+++ b/devtools/server/tests/browser/browser_animation_getMultipleStates.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check that the duration, iterationCount and delay are retrieved correctly for
 // multiple animations.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await playerHasAnInitialState(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
 });
--- a/devtools/server/tests/browser/browser_animation_getPlayers.js
+++ b/devtools/server/tests/browser/browser_animation_getPlayers.js
@@ -1,17 +1,17 @@
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check the output of getAnimationPlayersForNode
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await theRightNumberOfPlayersIsReturned(walker, animations);
   await playersCanBePausedAndResumed(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
--- a/devtools/server/tests/browser/browser_animation_getProperties.js
+++ b/devtools/server/tests/browser/browser_animation_getProperties.js
@@ -4,17 +4,17 @@
 
 "use strict";
 
 // Check that the AnimationPlayerActor exposes a getProperties method that
 // returns the list of animated properties in the animation.
 
 const URL = MAIN_DOMAIN + "animation.html";
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} = await initAnimationsFrontForUrl(URL);
 
   info("Get the test node and its animation front");
   let node = await walker.querySelector(walker.rootNode, ".simple-animation");
   let [player] = await animations.getAnimationPlayersForNode(node);
 
   ok(player.getProperties, "The front has the getProperties method");
 
--- a/devtools/server/tests/browser/browser_animation_getStateAfterFinished.js
+++ b/devtools/server/tests/browser/browser_animation_getStateAfterFinished.js
@@ -6,17 +6,17 @@
 "use strict";
 
 // Check that the right duration/iterationCount/delay are retrieved even when
 // the node has multiple animations and one of them already ended before getting
 // the player objects.
 // See devtools/server/actors/animation.js |getPlayerIndex| for more
 // information.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Retrieve a non animated node");
   let node = await walker.querySelector(walker.rootNode, ".not-animated");
 
   info("Apply the multiple-animations-2 class to start the animations");
   await node.modifyAttributes([
--- a/devtools/server/tests/browser/browser_animation_getSubTreeAnimations.js
+++ b/devtools/server/tests/browser/browser_animation_getSubTreeAnimations.js
@@ -4,17 +4,17 @@
 
 "use strict";
 
 // Check that the AnimationsActor can retrieve all animations inside a node's
 // subtree (but not going into iframes).
 
 const URL = MAIN_DOMAIN + "animation.html";
 
-add_task(async function() {
+add_task(async function () {
   info("Creating a test document with 2 iframes containing animated nodes");
 
   let {client, walker, animations} = await initAnimationsFrontForUrl(
     "data:text/html;charset=utf-8," +
     "<iframe id='iframe' src='" + URL + "'></iframe>");
 
   info("Try retrieving all animations from the root doc's <body> node");
   let rootBody = await walker.querySelector(walker.rootNode, "body");
--- a/devtools/server/tests/browser/browser_animation_keepFinished.js
+++ b/devtools/server/tests/browser/browser_animation_keepFinished.js
@@ -5,17 +5,17 @@
 
 "use strict";
 
 // Test that the AnimationsActor doesn't report finished animations as removed.
 // Indeed, animations that only have the "finished" playState can be modified
 // still, so we want the AnimationsActor to preserve the corresponding
 // AnimationPlayerActor.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Retrieve a non-animated node");
   let node = await walker.querySelector(walker.rootNode, ".not-animated");
 
   info("Retrieve the animation player for the node");
   let players = await animations.getAnimationPlayersForNode(node);
--- a/devtools/server/tests/browser/browser_animation_playPauseIframe.js
+++ b/devtools/server/tests/browser/browser_animation_playPauseIframe.js
@@ -4,17 +4,17 @@
 
 "use strict";
 
 // Check that the AnimationsActor can pause/play all animations even those
 // within iframes.
 
 const URL = MAIN_DOMAIN + "animation.html";
 
-add_task(async function() {
+add_task(async function () {
   info("Creating a test document with 2 iframes containing animated nodes");
 
   let {client, walker, animations} = await initAnimationsFrontForUrl(
     "data:text/html;charset=utf-8," +
     "<iframe id='i1' src='" + URL + "'></iframe>" +
     "<iframe id='i2' src='" + URL + "'></iframe>");
 
   info("Getting the 2 iframe container nodes and animated nodes in them");
--- a/devtools/server/tests/browser/browser_animation_playPauseSeveral.js
+++ b/devtools/server/tests/browser/browser_animation_playPauseSeveral.js
@@ -10,17 +10,17 @@
 // List of selectors that match "all" animated nodes in the test page.
 // This list misses a bunch of animated nodes on purpose. Only the ones that
 // have infinite animations are listed. This is done to avoid intermittents
 // caused when finite animations are already done playing by the time the test
 // runs.
 const ALL_ANIMATED_NODES = [".simple-animation", ".multiple-animations",
                             ".delayed-animation"];
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Pause all animations in the test document");
   await animations.pauseAll();
   await checkStates(walker, animations, ALL_ANIMATED_NODES, "paused");
 
   info("Play all animations in the test document");
--- a/devtools/server/tests/browser/browser_animation_playerState.js
+++ b/devtools/server/tests/browser/browser_animation_playerState.js
@@ -1,17 +1,17 @@
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check the animation player's initial state
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await playerHasAnInitialState(walker, animations);
   await playerStateIsCorrect(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
--- a/devtools/server/tests/browser/browser_animation_reconstructState.js
+++ b/devtools/server/tests/browser/browser_animation_reconstructState.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check that, even though the AnimationPlayerActor only sends the bits of its
 // state that change, the front reconstructs the whole state everytime.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await playerHasCompleteStateAtAllTimes(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
 });
--- a/devtools/server/tests/browser/browser_animation_refreshTransitions.js
+++ b/devtools/server/tests/browser/browser_animation_refreshTransitions.js
@@ -3,17 +3,17 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // When a transition finishes, no "removed" event is sent because it may still
 // be used, but when it restarts again (transitions back), then a new
 // AnimationPlayerFront should be sent, and the old one should be removed.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Retrieve the test node");
   let node = await walker.querySelector(walker.rootNode, ".all-transitions");
 
   info("Retrieve the animation players for the node");
   let players = await animations.getAnimationPlayersForNode(node);
--- a/devtools/server/tests/browser/browser_animation_setCurrentTime.js
+++ b/devtools/server/tests/browser/browser_animation_setCurrentTime.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check that a player's currentTime can be changed and that the AnimationsActor
 // allows changing many players' currentTimes at once.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await testSetCurrentTime(walker, animations);
   await testSetCurrentTimes(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
--- a/devtools/server/tests/browser/browser_animation_setPlaybackRate.js
+++ b/devtools/server/tests/browser/browser_animation_setPlaybackRate.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Check that a player's playbackRate can be changed, and that multiple players
 // can have their rates changed at the same time.
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   info("Retrieve an animated node");
   let node = await walker.querySelector(walker.rootNode, ".simple-animation");
 
   info("Retrieve the animation player for the node");
   let [player] = await animations.getAnimationPlayersForNode(node);
--- a/devtools/server/tests/browser/browser_animation_simple.js
+++ b/devtools/server/tests/browser/browser_animation_simple.js
@@ -1,17 +1,17 @@
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Simple checks for the AnimationsActor
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} = await initAnimationsFrontForUrl(
     "data:text/html;charset=utf-8,<title>test</title><div></div>");
 
   ok(animations, "The AnimationsFront was created");
   ok(animations.getAnimationPlayersForNode,
      "The getAnimationPlayersForNode method exists");
   ok(animations.toggleAll, "The toggleAll method exists");
   ok(animations.playAll, "The playAll method exists");
--- a/devtools/server/tests/browser/browser_animation_updatedState.js
+++ b/devtools/server/tests/browser/browser_animation_updatedState.js
@@ -2,17 +2,17 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 /* eslint-disable mozilla/no-arbitrary-setTimeout */
 
 "use strict";
 
 // Check the animation player's updated state
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, animations} =
     await initAnimationsFrontForUrl(MAIN_DOMAIN + "animation.html");
 
   await playStateIsUpdatedDynamically(walker, animations);
 
   await client.close();
   gBrowser.removeCurrentTab();
 });
--- a/devtools/server/tests/browser/browser_layout_getGrids.js
+++ b/devtools/server/tests/browser/browser_layout_getGrids.js
@@ -102,17 +102,17 @@ const GRID_FRAGMENT_DATA = {
         start: 100,
         state: "static",
         type: "explicit"
       }
     ]
   }
 };
 
-add_task(async function() {
+add_task(async function () {
   let { client, walker, layout } = await initLayoutFrontForUrl(MAIN_DOMAIN + "grid.html");
   let grids = await layout.getGrids(walker.rootNode);
   let grid = grids[0];
   let { gridFragments } = grid;
 
   is(grids.length, 1, "One grid was returned.");
   is(gridFragments.length, 1, "One grid fragment was returned.");
   ok(Array.isArray(gridFragments), "An array of grid fragments was returned.");
--- a/devtools/server/tests/browser/browser_layout_simple.js
+++ b/devtools/server/tests/browser/browser_layout_simple.js
@@ -1,17 +1,17 @@
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 // Simple checks for the LayoutActor and GridActor
 
-add_task(async function() {
+add_task(async function () {
   let {client, walker, layout} = await initLayoutFrontForUrl(
     "data:text/html;charset=utf-8,<title>test</title><div></div>");
 
   ok(layout, "The LayoutFront was created");
   ok(layout.getGrids, "The getGrids method exists");
 
   let didThrow = false;
   try {
--- a/devtools/server/tests/browser/browser_markers-cycle-collection.js
+++ b/devtools/server/tests/browser/browser_markers-cycle-collection.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get "nsCycleCollector::Collect" and
  * "nsCycleCollector::ForgetSkippable" markers when we force cycle collection.
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   // This test runs very slowly on linux32 debug EC2 instances.
   requestLongerTimeout(2);
 
   await addTab(MAIN_DOMAIN + "doc_force_cc.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
--- a/devtools/server/tests/browser/browser_markers-docloading-01.js
+++ b/devtools/server/tests/browser/browser_markers-docloading-01.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get DOMContentLoaded and Load markers
  */
 "use strict";
 
 const { TimelineFront } = require("devtools/shared/fronts/timeline");
 const MARKER_NAMES = ["document::DOMContentLoaded", "document::Load"];
 
-add_task(async function() {
+add_task(async function () {
   let browser = await addTab(MAIN_DOMAIN + "doc_innerHTML.html");
   // eslint-disable-next-line mozilla/no-cpows-in-tests
   let doc = browser.contentDocumentAsCPOW;
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
--- a/devtools/server/tests/browser/browser_markers-docloading-02.js
+++ b/devtools/server/tests/browser/browser_markers-docloading-02.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get DOMContentLoaded and Load markers
  */
 "use strict";
 
 const { TimelineFront } = require("devtools/shared/fronts/timeline");
 const MARKER_NAMES = ["document::DOMContentLoaded", "document::Load"];
 
-add_task(async function() {
+add_task(async function () {
   let browser = await addTab(MAIN_DOMAIN + "doc_innerHTML.html");
   // eslint-disable-next-line mozilla/no-cpows-in-tests
   let doc = browser.contentDocumentAsCPOW;
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
--- a/devtools/server/tests/browser/browser_markers-docloading-03.js
+++ b/devtools/server/tests/browser/browser_markers-docloading-03.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get DOMContentLoaded and Load markers
  */
 "use strict";
 
 const { TimelineFront } = require("devtools/shared/fronts/timeline");
 const MARKER_NAMES = ["document::DOMContentLoaded", "document::Load"];
 
-add_task(async function() {
+add_task(async function () {
   let browser = await addTab(MAIN_DOMAIN + "doc_innerHTML.html");
   // eslint-disable-next-line mozilla/no-cpows-in-tests
   let doc = browser.contentDocumentAsCPOW;
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
--- a/devtools/server/tests/browser/browser_markers-gc.js
+++ b/devtools/server/tests/browser/browser_markers-gc.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get "GarbageCollection" markers.
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const MARKER_NAME = "GarbageCollection";
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_force_gc.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
   let rec = await front.startRecording({ withMarkers: true });
--- a/devtools/server/tests/browser/browser_markers-minor-gc.js
+++ b/devtools/server/tests/browser/browser_markers-minor-gc.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get "MinorGC" markers when we continue to steadily allocate
  * objects.
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   // This test runs very slowly on linux32 debug EC2 instances.
   requestLongerTimeout(2);
 
   await addTab(MAIN_DOMAIN + "doc_allocations.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
--- a/devtools/server/tests/browser/browser_markers-parse-html.js
+++ b/devtools/server/tests/browser/browser_markers-parse-html.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get "Parse HTML" markers.
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const MARKER_NAME = "Parse HTML";
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_innerHTML.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
   let rec = await front.startRecording({ withMarkers: true });
--- a/devtools/server/tests/browser/browser_markers-styles.js
+++ b/devtools/server/tests/browser/browser_markers-styles.js
@@ -4,17 +4,17 @@
 /**
  * Test that we get "Styles" markers with correct meta.
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const MARKER_NAME = "Styles";
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
   let rec = await front.startRecording({ withMarkers: true });
--- a/devtools/server/tests/browser/browser_markers-timestamp.js
+++ b/devtools/server/tests/browser/browser_markers-timestamp.js
@@ -6,17 +6,17 @@
  */
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const { pmmConsoleMethod, pmmLoadFrameScripts, pmmClearFrameScripts }
   = require("devtools/client/performance/test/helpers/profiler-mm-utils");
 const MARKER_NAME = "TimeStamp";
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
   let rec = await front.startRecording({ withMarkers: true });
--- a/devtools/server/tests/browser/browser_perf-allocation-data.js
+++ b/devtools/server/tests/browser/browser_perf-allocation-data.js
@@ -4,17 +4,17 @@
 /**
  * Test that we have allocation data coming from the front.
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_allocations.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_perf-profiler-01.js
+++ b/devtools/server/tests/browser/browser_perf-profiler-01.js
@@ -7,17 +7,17 @@
  * a recording is stopped.
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const { pmmIsProfilerActive, pmmLoadFrameScripts } = require("devtools/client/performance/test/helpers/profiler-mm-utils");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_perf-profiler-02.js
+++ b/devtools/server/tests/browser/browser_perf-profiler-02.js
@@ -6,17 +6,17 @@
  * is destroyed if there are other consumers using it.
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const { pmmIsProfilerActive, pmmLoadFrameScripts } = require("devtools/client/performance/test/helpers/profiler-mm-utils");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let firstFront = PerformanceFront(client, form);
   await firstFront.connect();
 
   pmmLoadFrameScripts(gBrowser);
--- a/devtools/server/tests/browser/browser_perf-profiler-03.js
+++ b/devtools/server/tests/browser/browser_perf-profiler-03.js
@@ -8,17 +8,17 @@
  * addon was installed and automatically activated the profiler module).
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 const { pmmIsProfilerActive, pmmStartProfiler, pmmLoadFrameScripts, pmmClearFrameScripts } = require("devtools/client/performance/test/helpers/profiler-mm-utils");
 
-add_task(async function() {
+add_task(async function () {
   // Ensure the profiler is already running when the test starts.
   pmmLoadFrameScripts(gBrowser);
   let entries = 1000000;
   let interval = 1;
   let features = ["js"];
   await pmmStartProfiler({ entries, interval, features });
 
   ok((await pmmIsProfilerActive()),
--- a/devtools/server/tests/browser/browser_perf-realtime-markers.js
+++ b/devtools/server/tests/browser/browser_perf-realtime-markers.js
@@ -4,17 +4,17 @@
 /**
  * Test functionality of real time markers.
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_perf-recording-actor-01.js
+++ b/devtools/server/tests/browser/browser_perf-recording-actor-01.js
@@ -5,17 +5,17 @@
  * Tests the state of a recording rec from start to finish for recording,
  * completed, and rec data.
  */
 
 "use strict";
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_perf-recording-actor-02.js
+++ b/devtools/server/tests/browser/browser_perf-recording-actor-02.js
@@ -7,17 +7,17 @@
 
 "use strict";
 
 var BUFFER_SIZE = 20000;
 var config = { bufferSize: BUFFER_SIZE };
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_perf-samples-01.js
+++ b/devtools/server/tests/browser/browser_perf-samples-01.js
@@ -8,17 +8,17 @@
 
 "use strict";
 
 // time in ms
 const WAIT_TIME = 1000;
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await SpecialPowers.pushPrefEnv({"set": [["privacy.reduceTimerPrecision", false]]});
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
--- a/devtools/server/tests/browser/browser_perf-samples-02.js
+++ b/devtools/server/tests/browser/browser_perf-samples-02.js
@@ -9,17 +9,17 @@
 
 "use strict";
 
 // Time in ms
 const WAIT_TIME = 1000;
 
 const { PerformanceFront } = require("devtools/shared/fronts/performance");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "doc_perf.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = PerformanceFront(client, form);
   await front.connect();
 
--- a/devtools/server/tests/browser/browser_register_actor.js
+++ b/devtools/server/tests/browser/browser_register_actor.js
@@ -46,17 +46,17 @@ function cleanupActor(actorFront) {
 
 function getCount(actor, callback) {
   return gClient.request({
     to: actor,
     type: "count"
   }, callback);
 }
 
-var checkActorState = async function(helloActor, callback) {
+var checkActorState = async function (helloActor, callback) {
   let response = await getCount(helloActor);
   ok(!response.error, "No error");
   is(response.count, 1, "The counter must be valid");
 
   response = await getCount(helloActor);
   ok(!response.error, "No error");
   is(response.count, 2, "The counter must be valid");
 
--- a/devtools/server/tests/browser/browser_storage_cookies-duplicate-names.js
+++ b/devtools/server/tests/browser/browser_storage_cookies-duplicate-names.js
@@ -37,17 +37,17 @@ const TESTDATA = {
       path: "/path3/",
       host: "test1.example.org",
       isDomain: false,
       isSecure: false,
     }
   ]
 };
 
-add_task(async function() {
+add_task(async function () {
   await openTabAndSetupStorage(MAIN_DOMAIN + "storage-cookies-same-name.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = StorageFront(client, form);
   let data = await front.listStores();
 
@@ -65,17 +65,17 @@ add_task(async function() {
 });
 
 function testCookies(cookiesActor) {
   let numHosts = Object.keys(cookiesActor.hosts).length;
   is(numHosts, 1, "Correct number of host entries for cookies");
   return testCookiesObjects(0, cookiesActor.hosts, cookiesActor);
 }
 
-var testCookiesObjects = async function(index, hosts, cookiesActor) {
+var testCookiesObjects = async function (index, hosts, cookiesActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = data => {
     is(data.total, TESTDATA[host].length,
        "Number of cookies in host " + host + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of TESTDATA[host]) {
         if (item.name === toMatch.name &&
--- a/devtools/server/tests/browser/browser_storage_dynamic_windows.js
+++ b/devtools/server/tests/browser/browser_storage_dynamic_windows.js
@@ -237,17 +237,17 @@ function testRemoveIframe(front) {
           iframe.remove();
           break;
         }
       }
     });
   });
 }
 
-add_task(async function() {
+add_task(async function () {
   await openTabAndSetupStorage(MAIN_DOMAIN + "storage-dynamic-windows.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = StorageFront(client, form);
   let data = await front.listStores();
   await testStores(data, front);
--- a/devtools/server/tests/browser/browser_storage_listings.js
+++ b/devtools/server/tests/browser/browser_storage_listings.js
@@ -343,17 +343,17 @@ async function testStores(data) {
 }
 
 function testCookies(cookiesActor) {
   is(Object.keys(cookiesActor.hosts).length, 3,
                  "Correct number of host entries for cookies");
   return testCookiesObjects(0, cookiesActor.hosts, cookiesActor);
 }
 
-var testCookiesObjects = async function(index, hosts, cookiesActor) {
+var testCookiesObjects = async function (index, hosts, cookiesActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = data => {
     let cookiesLength = 0;
     for (let secureCookie of storeMap.cookies[host]) {
       if (secureCookie.isSecure) {
         ++cookiesLength;
       }
     }
@@ -388,17 +388,17 @@ var testCookiesObjects = async function(
 };
 
 function testLocalStorage(localStorageActor) {
   is(Object.keys(localStorageActor.hosts).length, 3,
      "Correct number of host entries for local storage");
   return testLocalStorageObjects(0, localStorageActor.hosts, localStorageActor);
 }
 
-var testLocalStorageObjects = async function(index, hosts, localStorageActor) {
+var testLocalStorageObjects = async function (index, hosts, localStorageActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = data => {
     is(data.total, storeMap.localStorage[host].length,
        "Number of local storage items in host " + host + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of storeMap.localStorage[host]) {
         if (item.name == toMatch.name) {
@@ -422,17 +422,17 @@ var testLocalStorageObjects = async func
 
 function testSessionStorage(sessionStorageActor) {
   is(Object.keys(sessionStorageActor.hosts).length, 3,
      "Correct number of host entries for session storage");
   return testSessionStorageObjects(0, sessionStorageActor.hosts,
                                    sessionStorageActor);
 }
 
-var testSessionStorageObjects = async function(index, hosts, sessionStorageActor) {
+var testSessionStorageObjects = async function (index, hosts, sessionStorageActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = data => {
     is(data.total, storeMap.sessionStorage[host].length,
        "Number of session storage items in host " + host + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of storeMap.sessionStorage[host]) {
         if (item.name == toMatch.name) {
@@ -449,17 +449,17 @@ var testSessionStorageObjects = async fu
   ok(!!storeMap.sessionStorage[host], "Host is present in the list : " + host);
   matchItems(await sessionStorageActor.getStoreObjects(host));
   if (index == Object.keys(hosts).length - 1) {
     return;
   }
   await testSessionStorageObjects(++index, hosts, sessionStorageActor);
 };
 
-var testIndexedDB = async function(indexedDBActor) {
+var testIndexedDB = async function (indexedDBActor) {
   is(Object.keys(indexedDBActor.hosts).length, 3,
      "Correct number of host entries for indexed db");
 
   for (let host in indexedDBActor.hosts) {
     for (let item of indexedDBActor.hosts[host]) {
       let parsedItem = JSON.parse(item);
       let found = false;
       for (let toMatch of IDBValues.listStoresResponse[host]) {
@@ -472,17 +472,17 @@ var testIndexedDB = async function(index
     }
   }
 
   await testIndexedDBs(0, indexedDBActor.hosts, indexedDBActor);
   await testObjectStores(0, indexedDBActor.hosts, indexedDBActor);
   await testIDBEntries(0, indexedDBActor.hosts, indexedDBActor);
 };
 
-var testIndexedDBs = async function(index, hosts, indexedDBActor) {
+var testIndexedDBs = async function (index, hosts, indexedDBActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = data => {
     is(data.total, IDBValues.dbDetails[host].length,
        "Number of indexed db in host " + host + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of IDBValues.dbDetails[host]) {
         if (item.uniqueKey == toMatch.db) {
@@ -502,17 +502,17 @@ var testIndexedDBs = async function(inde
   ok(!!IDBValues.dbDetails[host], "Host is present in the list : " + host);
   matchItems(await indexedDBActor.getStoreObjects(host));
   if (index == Object.keys(hosts).length - 1) {
     return;
   }
   await testIndexedDBs(++index, hosts, indexedDBActor);
 };
 
-var testObjectStores = async function(ix, hosts, indexedDBActor) {
+var testObjectStores = async function (ix, hosts, indexedDBActor) {
   let host = Object.keys(hosts)[ix];
   let matchItems = (data, db) => {
     is(data.total, IDBValues.objectStoreDetails[host][db].length,
        "Number of object stores in host " + host + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of IDBValues.objectStoreDetails[host][db]) {
         if (item.objectStore == toMatch.objectStore) {
@@ -553,17 +553,17 @@ var testObjectStores = async function(ix
     ), objName[0]);
   }
   if (ix == Object.keys(hosts).length - 1) {
     return;
   }
   await testObjectStores(++ix, hosts, indexedDBActor);
 };
 
-var testIDBEntries = async function(index, hosts, indexedDBActor) {
+var testIDBEntries = async function (index, hosts, indexedDBActor) {
   let host = Object.keys(hosts)[index];
   let matchItems = (data, obj) => {
     is(data.total, IDBValues.entries[host][obj].length,
        "Number of items in object store " + obj + " matches");
     for (let item of data.data) {
       let found = false;
       for (let toMatch of IDBValues.entries[host][obj]) {
         if (item.name == toMatch.name) {
@@ -591,17 +591,17 @@ var testIDBEntries = async function(inde
     ), parsed[0] + "#" + parsed[1]);
   }
   if (index == Object.keys(hosts).length - 1) {
     return;
   }
   await testObjectStores(++index, hosts, indexedDBActor);
 };
 
-add_task(async function() {
+add_task(async function () {
   await openTabAndSetupStorage(MAIN_DOMAIN + "storage-listings.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = StorageFront(client, form);
   let data = await front.listStores();
   await testStores(data);
--- a/devtools/server/tests/browser/browser_storage_updates.js
+++ b/devtools/server/tests/browser/browser_storage_updates.js
@@ -291,17 +291,17 @@ function storesCleared(data) {
 }
 
 async function finishTests(client) {
   await client.close();
   DebuggerServer.destroy();
   finish();
 }
 
-add_task(async function() {
+add_task(async function () {
   let browser = await addTab(MAIN_DOMAIN + "storage-updates.html");
   // eslint-disable-next-line mozilla/no-cpows-in-tests
   let doc = browser.contentDocumentAsCPOW;
 
   initDebuggerServer();
 
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
--- a/devtools/server/tests/browser/browser_stylesheets_getTextEmpty.js
+++ b/devtools/server/tests/browser/browser_stylesheets_getTextEmpty.js
@@ -6,17 +6,17 @@
 
 // Test that StyleSheetActor.getText handles empty text correctly.
 
 const {StyleSheetsFront} = require("devtools/shared/fronts/stylesheets");
 
 const CONTENT = "<style>body { background-color: #f06; }</style>";
 const TEST_URI = "data:text/html;charset=utf-8," + encodeURIComponent(CONTENT);
 
-add_task(async function() {
+add_task(async function () {
   await addTab(TEST_URI);
 
   info("Initialising the debugger server and client.");
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
 
   info("Attaching to the active tab.");
--- a/devtools/server/tests/browser/browser_stylesheets_nested-iframes.js
+++ b/devtools/server/tests/browser/browser_stylesheets_nested-iframes.js
@@ -4,17 +4,17 @@
 
 "use strict";
 
 // Test that StyleSheetsActor.getStyleSheets() works if an iframe does not have
 // a content document.
 
 const {StyleSheetsFront} = require("devtools/shared/fronts/stylesheets");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "stylesheets-nested-iframes.html");
 
   info("Initialising the debugger server and client.");
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
 
   info("Attaching to the active tab.");
--- a/devtools/server/tests/browser/browser_timeline.js
+++ b/devtools/server/tests/browser/browser_timeline.js
@@ -7,17 +7,17 @@
 // Test that the timeline front's start/stop/isRecording methods work in a
 // simple use case, and that markers events are sent when operations occur.
 // Note that this test isn't concerned with which markers are actually recorded,
 // just that markers are recorded at all.
 // Trying to check marker types here may lead to intermittents, see bug 1066474.
 
 const {TimelineFront} = require("devtools/shared/fronts/timeline");
 
-add_task(async function() {
+add_task(async function () {
   await addTab("data:text/html;charset=utf-8,mop");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
 
   ok(front, "The TimelineFront was created");
--- a/devtools/server/tests/browser/browser_timeline_actors.js
+++ b/devtools/server/tests/browser/browser_timeline_actors.js
@@ -5,17 +5,17 @@
 
 "use strict";
 
 // Test that the timeline can also record data from the memory and framerate
 // actors, emitted as events in tadem with the markers.
 
 const {TimelineFront} = require("devtools/shared/fronts/timeline");
 
-add_task(async function() {
+add_task(async function () {
   await addTab("data:text/html;charset=utf-8,mop");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
 
   info("Start timeline marker recording");
--- a/devtools/server/tests/browser/browser_timeline_iframes.js
+++ b/devtools/server/tests/browser/browser_timeline_iframes.js
@@ -5,17 +5,17 @@
 
 "use strict";
 
 // Test the timeline front receives markers events for operations that occur in
 // iframes.
 
 const {TimelineFront} = require("devtools/shared/fronts/timeline");
 
-add_task(async function() {
+add_task(async function () {
   await addTab(MAIN_DOMAIN + "timeline-iframe-parent.html");
 
   initDebuggerServer();
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   let form = await connectDebuggerClient(client);
   let front = TimelineFront(client, form);
 
   info("Start timeline marker recording");
--- a/devtools/server/tests/browser/head.js
+++ b/devtools/server/tests/browser/head.js
@@ -30,17 +30,17 @@ waitForExplicitFinish();
 /**
  * Add a new test tab in the browser and load the given url.
  * @param {String} url The url to be loaded in the new tab
  * @return a promise that resolves to the new browser that the document
  *         is loaded in. Note that we cannot return the document
  *         directly, since this would be a CPOW in the e10s case,
  *         and Promises cannot be resolved with CPOWs (see bug 1233497).
  */
-var addTab = async function(url) {
+var addTab = async function (url) {
   info(`Adding a new tab with URL: ${url}`);
   let tab = gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, url);
   await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
 
   info(`Tab added and URL ${url} loaded`);
 
   return tab.linkedBrowser;
 };
--- a/devtools/server/tests/browser/storage-dynamic-windows.html
+++ b/devtools/server/tests/browser/storage-dynamic-windows.html
@@ -21,17 +21,17 @@ document.cookie = "cs2=sessionCookie; pa
 document.cookie = "c3=foobar-2; expires=" +
   new Date(cookieExpiresTime2).toGMTString() + "; path=/";
 // ... and some local storage items ..
 localStorage.setItem("ls1", "foobar");
 localStorage.setItem("ls2", "foobar-2");
 // ... and finally some session storage items too
 sessionStorage.setItem("ss1", "foobar-3");
 
-let idbGenerator = async function() {
+let idbGenerator = async function () {
   let request = indexedDB.open("idb1", 1);
   request.onerror = function() {
     throw new Error("error opening db connection");
   };
   let db = await new Promise(done => {
     request.onupgradeneeded = event => {
       let db = event.target.result;
       let store1 = db.createObjectStore("obj1", { keyPath: "id" });
@@ -90,21 +90,21 @@ let idbGenerator = async function() {
 
 function deleteDB(dbName) {
   return new Promise(resolve => {
     dump("removing database " + dbName + " from " + document.location + "\n");
     indexedDB.deleteDatabase(dbName).onsuccess = resolve;
   });
 }
 
-window.setup = async function() {
+window.setup = async function () {
   await idbGenerator();
 };
 
-window.clear = async function() {
+window.clear = async function () {
   document.cookie = "c1=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
   document.cookie = "c3=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
   document.cookie = "cs2=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
 
   localStorage.clear();
 
   await deleteDB("idb1");
   await deleteDB("idb2");
--- a/devtools/server/tests/browser/storage-helpers.js
+++ b/devtools/server/tests/browser/storage-helpers.js
@@ -12,17 +12,17 @@
  * @param url {String} The url to be opened in the new tab
  *
  * @return {Promise} A promise that resolves after storage inspector is ready
  */
 async function openTabAndSetupStorage(url) {
   let content = await addTab(url);
 
   // Setup the async storages in main window and for all its iframes
-  await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
+  await ContentTask.spawn(gBrowser.selectedBrowser, null, async function () {
     /**
      * Get all windows including frames recursively.
      *
      * @param {Window} [baseWindow]
      *        The base window at which to start looking for child windows
      *        (optional).
      * @return {Set}
      *         A set of windows.
@@ -47,17 +47,17 @@ async function openTabAndSetupStorage(ur
       if (win.setup) {
         await win.setup();
       }
     }
   });
 }
 
 async function clearStorage() {
-  await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
+  await ContentTask.spawn(gBrowser.selectedBrowser, null, async function () {
     /**
      * Get all windows including frames recursively.
      *
      * @param {Window} [baseWindow]
      *        The base window at which to start looking for child windows
      *        (optional).
      * @return {Set}
      *         A set of windows.
--- a/devtools/server/tests/browser/storage-listings.html
+++ b/devtools/server/tests/browser/storage-listings.html
@@ -23,17 +23,17 @@ document.cookie = "c3=foobar-2; secure=t
   new Date(cookieExpiresTime2).toGMTString() + "; path=/";
 // ... and some local storage items ..
 localStorage.setItem("ls1", "foobar");
 localStorage.setItem("ls2", "foobar-2");
 // ... and finally some session storage items too
 sessionStorage.setItem("ss1", "foobar-3");
 console.log("added cookies and stuff from main page");
 
-let idbGenerator = async function() {
+let idbGenerator = async function () {
   let request = indexedDB.open("idb1", 1);
   request.onerror = function() {
     throw new Error("error opening db connection");
   };
   let db = await new Promise(done => {
     request.onupgradeneeded = event => {
       let db = event.target.result;
       let store1 = db.createObjectStore("obj1", { keyPath: "id" });
@@ -92,21 +92,21 @@ let idbGenerator = async function() {
 
 function deleteDB(dbName) {
   return new Promise(resolve => {
     dump("removing database " + dbName + " from " + document.location + "\n");
     indexedDB.deleteDatabase(dbName).onsuccess = resolve;
   });
 }
 
-window.setup = async function() {
+window.setup = async function () {
   await idbGenerator();
 };
 
-window.clear = async function() {
+window.clear = async function () {
   document.cookie = "c1=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/browser";
   document.cookie =
     "c3=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; secure=true";
   document.cookie =
     "cs2=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=" +
     partialHostname;
 
   localStorage.clear();
--- a/devtools/server/tests/browser/storage-secured-iframe.html
+++ b/devtools/server/tests/browser/storage-secured-iframe.html
@@ -8,17 +8,17 @@ Iframe for testing multiple host detetio
 </head>
 <body>
 <script type="application/javascript">
 
 document.cookie = "sc1=foobar;";
 localStorage.setItem("iframe-s-ls1", "foobar");
 sessionStorage.setItem("iframe-s-ss1", "foobar-2");
 
-let idbGenerator = async function() {
+let idbGenerator = async function () {
   let request = indexedDB.open("idb-s1", 1);
   request.onerror = function() {
     throw new Error("error opening db connection");
   };
   let db = await new Promise(done => {
     request.onupgradeneeded = event => {
       let db = event.target.result;
       let store1 = db.createObjectStore("obj-s1", { keyPath: "id" });
@@ -70,21 +70,21 @@ let idbGenerator = async function() {
 
 function deleteDB(dbName) {
   return new Promise(resolve => {
     dump("removing database " + dbName + " from " + document.location + "\n");
     indexedDB.deleteDatabase(dbName).onsuccess = resolve;
   });
 }
 
-window.setup = async function() {
+window.setup = async function () {
   await idbGenerator();
 };
 
-window.clear = async function() {
+window.clear = async function () {
   document.cookie = "sc1=; expires=Thu, 01 Jan 1970 00:00:00 GMT";
 
   localStorage.clear();
 
   await deleteDB("idb-s1");
   await deleteDB("idb-s2");
 
   console.log("removed cookies and stuff from secured iframe");
--- a/devtools/server/tests/mochitest/test_css-properties.html
+++ b/devtools/server/tests/mochitest/test_css-properties.html
@@ -26,17 +26,17 @@ window.onload = function () {
       });
     });
   }
 
   function toSortedString(array) {
     return JSON.stringify(array.sort());
   }
 
-  const runCssPropertiesTests = async function(url, useActor) {
+  const runCssPropertiesTests = async function (url, useActor) {
     info(`Opening two tabs ${useActor ? "with" : "without"} CssPropertiesActor support.`);
 
     let attachmentA = await promiseAttachUrl(url);
     let attachmentB = await promiseAttachUrl(url);
 
     const toolboxMockA = {
       target: {
         hasActor: () => useActor,
--- a/devtools/server/tests/mochitest/test_inspector-dead-nodes.html
+++ b/devtools/server/tests/mochitest/test_inspector-dead-nodes.html
@@ -16,221 +16,221 @@ https://bugzilla.mozilla.org/show_bug.cg
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
   runNextTest();
 };
 
 let gWalker = null;
 let gDoc = null;
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   let url = document.getElementById("inspectorContent").href;
 
   let def = defer();
   attachURL(url, function (err, client, tab, doc) {
     def.resolve({client, tab, doc});
   });
   let {client, tab, doc} = await def.promise;
   gDoc = doc;
 
   let {InspectorFront} = require("devtools/shared/fronts/inspector");
   let inspector = InspectorFront(client, tab);
   gWalker = await inspector.getWalker();
 
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.parents(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.parents(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.parents() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.children(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "body");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.children(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.children() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.siblings(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.siblings(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.siblings() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.nextSibling(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.nextSibling(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.nextSibling() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.previousSibling(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.previousSibling(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.previousSibling() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.addPseudoClassLock(nodeFront) before the load completes " +
     "shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.addPseudoClassLock(nodeFront, ":hover");
   await newRoot;
 
   ok(true, "The call to walker.addPseudoClassLock() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.removePseudoClassLock(nodeFront) before the load completes " +
     "shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.removePseudoClassLock(nodeFront, ":hover");
   await newRoot;
 
   ok(true, "The call to walker.removePseudoClassLock() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.clearPseudoClassLocks(nodeFront) before the load completes " +
     "shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.clearPseudoClassLocks(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.clearPseudoClassLocks() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.innerHTML(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.innerHTML(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.innerHTML() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.setInnerHTML(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.setInnerHTML(nodeFront, "<span>innerHTML changed</span>");
   await newRoot;
 
   ok(true, "The call to walker.setInnerHTML() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.outerHTML(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.outerHTML(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.outerHTML() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.setOuterHTML(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.setOuterHTML(nodeFront, "<h1><span>innerHTML changed</span></h1>");
   await newRoot;
 
   ok(true, "The call to walker.setOuterHTML() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.insertAdjacentHTML(nodeFront) before the load completes shouldn't " +
     "fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.insertAdjacentHTML(nodeFront, "afterEnd",
     "<span>new adjacent HTML</span>");
   await newRoot;
 
   ok(true, "The call to walker.insertAdjacentHTML() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.removeNode(nodeFront) before the load completes should throw");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   let hasThrown = false;
   try {
@@ -239,17 +239,17 @@ addAsyncTest(async function() {
     hasThrown = true;
   }
   await newRoot;
 
   ok(hasThrown, "The call to walker.removeNode() threw");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.removeNodes([nodeFront]) before the load completes should throw");
 
   let nodeFront1 = await gWalker.querySelector(gWalker.rootNode, "h1");
   let nodeFront2 = await gWalker.querySelector(gWalker.rootNode, "#longstring");
   let nodeFront3 = await gWalker.querySelector(gWalker.rootNode, "#shortstring");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
@@ -260,106 +260,106 @@ addAsyncTest(async function() {
     hasThrown = true;
   }
   await newRoot;
 
   ok(hasThrown, "The call to walker.removeNodes() threw");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.insertBefore(nodeFront, parent, null) before the load completes " +
     "shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newParentFront = await gWalker.querySelector(gWalker.rootNode, "#longlist");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.insertBefore(nodeFront, newParentFront);
   await newRoot;
 
   ok(true, "The call to walker.insertBefore() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.insertBefore(nodeFront, parent, sibling) before the load completes " +
     "shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newParentFront = await gWalker.querySelector(gWalker.rootNode, "#longlist");
   let siblingFront = await gWalker.querySelector(gWalker.rootNode, "#b");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.insertBefore(nodeFront, newParentFront, siblingFront);
   await newRoot;
 
   ok(true, "The call to walker.insertBefore() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.editTagName(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.editTagName(nodeFront, "h2");
   await newRoot;
 
   ok(true, "The call to walker.editTagName() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.hideNode(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.hideNode(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.hideNode() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.unhideNode(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.unhideNode(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.unhideNode() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.releaseNode(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "h1");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.releaseNode(nodeFront);
   await newRoot;
 
   ok(true, "The call to walker.releaseNode() didn't fail");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   info("Getting a nodeFront, reloading the page, and calling " +
     "walker.querySelector(nodeFront) before the load completes shouldn't fail");
 
   let nodeFront = await gWalker.querySelector(gWalker.rootNode, "body");
   let newRoot = waitForMutation(gWalker, isNewRoot);
   gDoc.defaultView.location.reload();
   await gWalker.querySelector(nodeFront, "h1");
   await newRoot;
--- a/devtools/server/tests/mochitest/test_inspector-pick-color.html
+++ b/devtools/server/tests/mochitest/test_inspector-pick-color.html
@@ -18,47 +18,47 @@ https://bugzilla.mozilla.org/show_bug.cg
 window.onload = function () {
   const {InspectorFront} = require("devtools/shared/fronts/inspector");
 
   SimpleTest.waitForExplicitFinish();
 
   let win = null;
   let inspector = null;
 
-  addAsyncTest(async function() {
+  addAsyncTest(async function () {
     info("Setting up inspector actor");
 
     let url = document.getElementById("inspectorContent").href;
 
     await new Promise(resolve => {
       attachURL(url, function (err, client, tab, doc) {
         win = doc.defaultView;
         inspector = InspectorFront(client, tab);
         resolve();
       });
     });
 
     runNextTest();
   });
 
-  addAsyncTest(async function() {
+  addAsyncTest(async function () {
     info("Start picking a color from the page");
     await inspector.pickColorFromPage();
 
     info("Click in the page and make sure a color-picked event is received");
     let onColorPicked = waitForEvent("color-picked");
     win.document.body.click();
     let color = await onColorPicked;
 
     is(color, "#000000", "The color-picked event was received with the right color");
 
     runNextTest();
   });
 
-  addAsyncTest(async function() {
+  addAsyncTest(async function () {
     info("Start picking a color from the page");
     await inspector.pickColorFromPage();
 
     info("Use the escape key to dismiss the eyedropper");
     let onPickCanceled = waitForEvent("color-pick-canceled");
 
     let keyboardEvent = win.document.createEvent("KeyboardEvent");
     keyboardEvent.initKeyEvent("keydown", true, true, win, false, false,
@@ -66,17 +66,17 @@ window.onload = function () {
     win.document.dispatchEvent(keyboardEvent);
 
     await onPickCanceled;
     ok(true, "The color-pick-canceled event was received");
 
     runNextTest();
   });
 
-  addAsyncTest(async function() {
+  addAsyncTest(async function () {
     info("Start picking a color from the page");
     await inspector.pickColorFromPage();
 
     info("And cancel the color picking");
     await inspector.cancelPickColorFromPage();
 
     runNextTest();
   });
--- a/devtools/server/tests/mochitest/test_inspector-resize.html
+++ b/devtools/server/tests/mochitest/test_inspector-resize.html
@@ -34,17 +34,17 @@ window.onload = function () {
         inspector = InspectorFront(client, tab);
         resolve();
       });
     });
 
     runNextTest();
   });
 
-  addAsyncTest(async function() {
+  addAsyncTest(async function () {
     let walker = await inspector.getWalker();
 
     // We can't receive events from the walker if we haven't first executed a
     // method on the actor to initialize it.
     await walker.querySelector(walker.rootNode, "img");
 
     let {outerWidth, outerHeight} = win;
     // eslint-disable-next-line new-cap
--- a/devtools/server/tests/mochitest/test_memory.html
+++ b/devtools/server/tests/mochitest/test_memory.html
@@ -13,17 +13,17 @@ Bug 923275 - Add a memory monitor widget
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     let measurement = await memory.measure();
     ok(measurement.total > 0, "total memory is valid");
     ok(measurement.domSize > 0, "domSize is valid");
     ok(measurement.styleSize > 0, "styleSize is valid");
     ok(measurement.jsObjectsSize > 0, "jsObjectsSize is valid");
     ok(measurement.jsStringsSize > 0, "jsStringsSize is valid");
     ok(measurement.jsOtherSize > 0, "jsOtherSize is valid");
--- a/devtools/server/tests/mochitest/test_memory_allocations_02.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_02.html
@@ -13,17 +13,17 @@ Bug 1132764 - Test controlling the maxim
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let allocs = [];
     let eventsFired = 0;
     let intervalId = null;
     function onAlloc() {
       eventsFired++;
--- a/devtools/server/tests/mochitest/test_memory_allocations_03.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_03.html
@@ -13,17 +13,17 @@ Bug 1067491 - Test that frames keep the 
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     await memory.startRecordingAllocations();
 
     // Allocate twice with the exact same stack (hence setTimeout rather than
     // allocating directly in the generator), but with getAllocations() calls in
     // between.
--- a/devtools/server/tests/mochitest/test_memory_allocations_04.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_04.html
@@ -13,28 +13,28 @@ Bug 1068171 - Test controlling the memor
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let allocs = [];
     function allocator() {
       for (let i = 0; i < 100; i++) {
         allocs.push({});
       }
     }
 
-    let testProbability = async function(p, expected) {
+    let testProbability = async function (p, expected) {
       info("probability = " + p);
       await memory.startRecordingAllocations({
         probability: p
       });
       allocator();
       let response = await memory.getAllocations();
       await memory.stopRecordingAllocations();
       return response.allocations.length;
--- a/devtools/server/tests/mochitest/test_memory_allocations_05.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_05.html
@@ -13,17 +13,17 @@ Bug 1068144 - Test getting the timestamp
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let allocs = [];
     function allocator() {
       allocs.push(new Object());
     }
 
--- a/devtools/server/tests/mochitest/test_memory_allocations_06.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_06.html
@@ -13,17 +13,17 @@ Bug 1132764 - Test controlling the maxim
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let allocs = [];
     function allocator() {
       allocs.push(new Object());
     }
 
--- a/devtools/server/tests/mochitest/test_memory_allocations_07.html
+++ b/devtools/server/tests/mochitest/test_memory_allocations_07.html
@@ -13,17 +13,17 @@ Bug 1192335 - Test getting the byte size
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let allocs = [];
     function allocator() {
       allocs.push(new Object());
     }
 
--- a/devtools/server/tests/mochitest/test_memory_attach_01.html
+++ b/devtools/server/tests/mochitest/test_memory_attach_01.html
@@ -13,17 +13,17 @@ Bug 960671 - Test attaching and detachin
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
     ok(true, "Shouldn't have gotten an error attaching.");
     await memory.detach();
     ok(true, "Shouldn't have gotten an error detaching.");
     destroyServerAndFinish(client);
   })();
 };
--- a/devtools/server/tests/mochitest/test_memory_attach_02.html
+++ b/devtools/server/tests/mochitest/test_memory_attach_02.html
@@ -13,17 +13,17 @@ Bug 960671 - Test attaching and detachin
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
 
     let e = null;
     try {
       await memory.detach();
     } catch (ee) {
       e = ee;
     }
--- a/devtools/server/tests/mochitest/test_memory_census.html
+++ b/devtools/server/tests/mochitest/test_memory_census.html
@@ -13,17 +13,17 @@ Bug 1067491 - Test taking a census over 
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let census = await memory.takeCensus();
     is(typeof census, "object");
 
     await memory.detach();
     destroyServerAndFinish(client);
--- a/devtools/server/tests/mochitest/test_memory_gc_01.html
+++ b/devtools/server/tests/mochitest/test_memory_gc_01.html
@@ -13,17 +13,17 @@ Bug 1067491 - Test forcing a gc.
 <pre id="test">
 <script src="memory-helpers.js" type="application/javascript"></script>
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
 
     let beforeGC, afterGC;
 
     do {
       let objects = [];
       for (let i = 0; i < 1000; i++) {
         let o = {};
--- a/devtools/server/tests/mochitest/test_memory_gc_events.html
+++ b/devtools/server/tests/mochitest/test_memory_gc_events.html
@@ -15,17 +15,17 @@ Bug 1137527 - Test receiving GC events f
 <script>
 "use strict";
 
 window.onload = function () {
   SimpleTest.waitForExplicitFinish();
 
   let EventEmitter = require("devtools/shared/event-emitter");
 
-  (async function() {
+  (async function () {
     let { memory, client } = await startServerAndGetSelectedTabMemory();
     await memory.attach();
 
     let gotGcEvent = new Promise(resolve => {
       EventEmitter.on(memory, "garbage-collection", gcData => {
         ok(gcData, "Got GC data");
         resolve();
       });
--- a/devtools/server/tests/mochitest/test_styles-layout.html
+++ b/devtools/server/tests/mochitest/test_styles-layout.html
@@ -32,17 +32,17 @@ addTest(function () {
   });
 });
 
 addTest(function () {
   ok(gStyles.getLayout, "The PageStyleActor has a getLayout method");
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   let node = await gWalker.querySelector(gWalker.rootNode, "#layout-element");
   let layout = await gStyles.getLayout(node, {});
 
   let properties = ["width", "height",
                     "margin-top", "margin-right", "margin-bottom",
                     "margin-left", "padding-top", "padding-right",
                     "padding-bottom", "padding-left", "border-top-width",
                     "border-right-width", "border-bottom-width",
@@ -50,17 +50,17 @@ addAsyncTest(async function() {
                     "position"];
   for (let prop of properties) {
     ok((prop in layout), "The layout object returned has " + prop);
   }
 
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   let node = await gWalker.querySelector(gWalker.rootNode, "#layout-element");
   let layout = await gStyles.getLayout(node, {});
 
   let expected = {
     "box-sizing": "border-box",
     "position": "absolute",
     "z-index": "2",
     "display": "block",
@@ -74,17 +74,17 @@ addAsyncTest(async function() {
 
   for (let name in expected) {
     is(layout[name], expected[name], "The " + name + " property is correct");
   }
 
   runNextTest();
 });
 
-addAsyncTest(async function() {
+addAsyncTest(async function () {
   let node = await gWalker.querySelector(gWalker.rootNode,
                                          "#layout-auto-margin-element");
 
   let layout = await gStyles.getLayout(node, {});
   ok(!("autoMargins" in layout),
      "By default, getLayout doesn't return auto margins");
 
   layout = await gStyles.getLayout(node, {autoMargins: true});
--- a/devtools/server/tests/mochitest/test_websocket-server.html
+++ b/devtools/server/tests/mochitest/test_websocket-server.html
@@ -15,17 +15,17 @@ window.onload = function () {
   const CC = Components.Constructor;
   const { require } = ChromeUtils.import("resource://devtools/shared/Loader.jsm", {});
   const { Task } = require("devtools/shared/task");
   const WebSocketServer = require("devtools/server/websocket-server");
 
   const ServerSocket = CC("@mozilla.org/network/server-socket;1",
     "nsIServerSocket", "init");
 
-  add_task(async function() {
+  add_task(async function () {
     // Create a TCP server on auto-assigned port
     let server = new ServerSocket(-1, true, -1);
     ok(server, `Launched WebSocket server on port ${server.port}`);
 
     let input, output;
 
     server.asyncListen({
       async onSocketAccepted(socket, transport) {
--- a/devtools/server/tests/mochitest/webconsole-helpers.js
+++ b/devtools/server/tests/mochitest/webconsole-helpers.js
@@ -33,17 +33,17 @@ if (!DebuggerServer.initialized) {
  *           - consoleClient: the console client
  *           - cleanup: a generator function which can be called to close
  *             the opened tab and disconnect its debugger client.
  */
 async function attachURL(url) {
   let win = window.open(url, "_blank");
   let client = null;
 
-  let cleanup = async function() {
+  let cleanup = async function () {
     if (client) {
       await client.close();
       client = null;
     }
     if (win) {
       win.close();
       win = null;
     }
--- a/devtools/server/tests/unit/head_dbg.js
+++ b/devtools/server/tests/unit/head_dbg.js
@@ -87,17 +87,17 @@ function makeMemoryActorTest(testGenerat
       });
 
       getTestTab(client, TEST_GLOBAL_NAME, function (tabForm, rootForm) {
         if (!tabForm || !rootForm) {
           ok(false, "Could not attach to test tab: " + TEST_GLOBAL_NAME);
           return;
         }
 
-        (async function() {
+        (async function () {
           try {
             const memoryFront = new MemoryFront(client, tabForm, rootForm);
             await memoryFront.attach();
             await testGeneratorFunction(client, memoryFront);
             await memoryFront.detach();
           } catch (err) {
             DevToolsUtils.reportException("makeMemoryActorTest", err);
             ok(false, "Got an error: " + err);
@@ -125,17 +125,17 @@ function makeFullRuntimeMemoryActorTest(
       });
 
       getChromeActors(client).then(function (form) {
         if (!form) {
           ok(false, "Could not attach to chrome actors");
           return;
         }
 
-        (async function() {
+        (async function () {
           try {
             const rootForm = await listTabs(client);
             const memoryFront = new MemoryFront(client, form, rootForm);
             await memoryFront.attach();
             await testGeneratorFunction(client, memoryFront);
             await memoryFront.detach();
           } catch (err) {
             DevToolsUtils.reportException("makeMemoryActorTest", err);
--- a/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_01.js
+++ b/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_01.js
@@ -3,16 +3,16 @@
 
 "use strict";
 
 // Test that we can tell the memory actor to take a heap snapshot over the RDP
 // and then create a HeapSnapshot instance from the resulting file.
 
 const { OS } = require("resource://gre/modules/osfile.jsm");
 
-const run_test = makeMemoryActorTest(async function(client, memoryFront) {
+const run_test = makeMemoryActorTest(async function (client, memoryFront) {
   const snapshotFilePath = await memoryFront.saveHeapSnapshot();
   ok(!!(await OS.File.stat(snapshotFilePath)),
      "Should have the heap snapshot file");
   const snapshot = ChromeUtils.readHeapSnapshot(snapshotFilePath);
   ok(snapshot instanceof HeapSnapshot,
      "And we should be able to read a HeapSnapshot instance from the file");
 });
--- a/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_02.js
+++ b/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_02.js
@@ -3,17 +3,17 @@
 
 "use strict";
 
 // Test that we can properly stream heap snapshot files over the RDP as bulk
 // data.
 
 const { OS } = require("resource://gre/modules/osfile.jsm");
 
-const run_test = makeMemoryActorTest(async function(client, memoryFront) {
+const run_test = makeMemoryActorTest(async function (client, memoryFront) {
   const snapshotFilePath = await memoryFront.saveHeapSnapshot({
     forceCopy: true
   });
   ok(!!(await OS.File.stat(snapshotFilePath)),
      "Should have the heap snapshot file");
   const snapshot = ChromeUtils.readHeapSnapshot(snapshotFilePath);
   ok(snapshot instanceof HeapSnapshot,
      "And we should be able to read a HeapSnapshot instance from the file");
--- a/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_03.js
+++ b/devtools/server/tests/unit/test_MemoryActor_saveHeapSnapshot_03.js
@@ -3,16 +3,16 @@
 
 "use strict";
 
 // Test that we can save full runtime heap snapshots when attached to the
 // ChromeActor or a ChildProcessActor.
 
 const { OS } = require("resource://gre/modules/osfile.jsm");
 
-const run_test = makeFullRuntimeMemoryActorTest(async function(client, memoryFront) {
+const run_test = makeFullRuntimeMemoryActorTest(async function (client, memoryFront) {
   const snapshotFilePath = await memoryFront.saveHeapSnapshot();
   ok(!!(await OS.File.stat(snapshotFilePath)),
      "Should have the heap snapshot file");
   const snapshot = ChromeUtils.readHeapSnapshot(snapshotFilePath);
   ok(snapshot instanceof HeapSnapshot,
      "And we should be able to read a HeapSnapshot instance from the file");
 });
--- a/devtools/server/tests/unit/test_blackboxing-01.js
+++ b/devtools/server/tests/unit/test_blackboxing-01.js
@@ -23,17 +23,17 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-const testBlackBox = async function() {
+const testBlackBox = async function () {
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
 
   await setBreakpoint(source, {
     line: 2
   });
   await resume(gThreadClient);
 
@@ -117,17 +117,17 @@ function evalCode() {
     gDebuggee,
     "1.8",
     SOURCE_URL,
     1
   );
   /* eslint-enable */
 }
 
-const runTest = async function(onSteppedLocation, onDebuggerStatementFrames) {
+const runTest = async function (onSteppedLocation, onDebuggerStatementFrames) {
   let packet = await executeOnNextTickAndWaitForPause(gDebuggee.runTest,
                                                       gClient);
   Assert.equal(packet.why.type, "breakpoint");
 
   await stepIn(gClient, gThreadClient);
 
   const location = await getCurrentLocation();
   onSteppedLocation(location);
@@ -136,12 +136,12 @@ const runTest = async function(onStepped
   Assert.equal(packet.why.type, "debuggerStatement");
 
   let { frames } = await getFrames(gThreadClient, 0, 100);
   onDebuggerStatementFrames(frames);
 
   return resume(gThreadClient);
 };
 
-const getCurrentLocation = async function() {
+const getCurrentLocation = async function () {
   const response = await getFrames(gThreadClient, 0, 1);
   return response.frames[0].where;
 };
--- a/devtools/server/tests/unit/test_blackboxing-07.js
+++ b/devtools/server/tests/unit/test_blackboxing-07.js
@@ -24,17 +24,17 @@ function run_test() {
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/black-boxed.min.js";
 const SOURCE_URL = "http://example.com/source.js";
 
-const testBlackBox = async function() {
+const testBlackBox = async function () {
   await executeOnNextTickAndWaitForPause(evalCode, gClient);
 
   const { sources } = await getSources(gThreadClient);
   equal(sources.length, 2);
 
   const blackBoxedSource = sources.filter(s => s.url === BLACK_BOXED_URL)[0];
   equal(blackBoxedSource.isBlackBoxed, true);
 
--- a/devtools/server/tests/unit/test_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_breakpoint-03.js
@@ -32,28 +32,28 @@ function run_test_with_server(server, ca
                            "test-stack",
                            function (response, tabClient, threadClient) {
                              gThreadClient = threadClient;
                              test_skip_breakpoint();
                            });
   });
 }
 
-var test_no_skip_breakpoint = async function(source, location) {
+var test_no_skip_breakpoint = async function (source, location) {
   let [response, bpClient] = await source.setBreakpoint(
     Object.assign({}, location, { noSliding: true })
   );
 
   Assert.ok(!response.actualLocation);
   Assert.equal(bpClient.location.line, gDebuggee.line0 + 3);
   await bpClient.remove();
 };
 
 var test_skip_breakpoint = function () {
-  gThreadClient.addOneTimeListener("paused", async function(event, packet) {
+  gThreadClient.addOneTimeListener("paused", async function (event, packet) {
     let location = { line: gDebuggee.line0 + 3 };
     let source = gThreadClient.source(packet.frame.where.source);
 
     // First, make sure that we can disable sliding with the
     // `noSliding` option.
     await test_no_skip_breakpoint(source, location);
 
     // Now make sure that the breakpoint properly slides forward one line.
--- a/devtools/server/tests/unit/test_breakpoint-13.js
+++ b/devtools/server/tests/unit/test_breakpoint-13.js
@@ -35,17 +35,17 @@ function run_test_with_server(server, ca
   });
 }
 
 function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
-    source.setBreakpoint(location, async function(response, bpClient) {
+    source.setBreakpoint(location, async function (response, bpClient) {
       const testCallbacks = [
         function (packet) {
           // Check that the stepping worked.
           Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
           Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Entered the foo function call frame.
--- a/devtools/server/tests/unit/test_breakpoint-14.js
+++ b/devtools/server/tests/unit/test_breakpoint-14.js
@@ -35,17 +35,17 @@ function run_test_with_server(server, ca
   });
 }
 
 function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function (event, packet) {
     let source = gThreadClient.source(packet.frame.where.source);
     let location = { line: gDebuggee.line0 + 2 };
 
-    source.setBreakpoint(location, async function(response, bpClient) {
+    source.setBreakpoint(location, async function (response, bpClient) {
       const testCallbacks = [
         function (packet) {
           // Check that the stepping worked.
           Assert.equal(packet.frame.where.line, gDebuggee.line0 + 5);
           Assert.equal(packet.why.type, "resumeLimit");
         },
         function (packet) {
           // Reached the breakpoint.
--- a/devtools/server/tests/unit/test_breakpoint-15.js
+++ b/devtools/server/tests/unit/test_breakpoint-15.js
@@ -22,17 +22,17 @@ function run_test() {
                              testSameBreakpoint();
                            });
   });
   do_test_pending();
 }
 
 const SOURCE_URL = "http://example.com/source.js";
 
-const testSameBreakpoint = async function() {
+const testSameBreakpoint = async function () {
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
 
   // Whole line
   let wholeLineLocation = {
     line: 2
   };
 
--- a/devtools/server/tests/unit/test_breakpoint-19.js
+++ b/devtools/server/tests/unit/test_breakpoint-19.js
@@ -46,17 +46,17 @@ function setUpCode() {
     "\ndebugger;",         // 5
     gDebuggee,
     "1.8",
     URL
   );
   /* eslint-enable */
 }
 
-const testBreakpoint = async function() {
+const testBreakpoint = async function () {
   let source = await getSource(gThreadClient, URL);
   let [response, ] = await setBreakpoint(source, {line: 2});
   ok(!response.error);
 
   let actor = response.actor;
   ok(actor);
 
   await executeOnNextTickAndWaitForPause(setUpCode, gClient);
--- a/devtools/server/tests/unit/test_breakpoint-20.js
+++ b/devtools/server/tests/unit/test_breakpoint-20.js
@@ -16,17 +16,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-breakpoints");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
     attachTestThread(gClient, "test-breakpoints", testBreakpoint);
   });
   do_test_pending();
 }
 
-const testBreakpoint = async function(threadResponse, tabClient,
+const testBreakpoint = async function (threadResponse, tabClient,
                                              threadClient, tabResponse) {
   evalSetupCode();
 
   // Load the test source once.
 
   evalTestCode();
   equal(gDebuggee.functions.length, 1,
         "The test code should have added a function.");
--- a/devtools/server/tests/unit/test_breakpoint-21.js
+++ b/devtools/server/tests/unit/test_breakpoint-21.js
@@ -29,17 +29,17 @@ function run_test_with_server(server, ca
                            "test-breakpoints",
                            function (response, tabClient, threadClient) {
                              gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
-const test = async function() {
+const test = async function () {
   // Populate the `ScriptStore` so that we only test that the script
   // is added through `onNewScript`
   await getSources(gThreadClient);
 
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
   let location = {
     line: gDebuggee.line0 + 8
--- a/devtools/server/tests/unit/test_breakpoint-22.js
+++ b/devtools/server/tests/unit/test_breakpoint-22.js
@@ -28,17 +28,17 @@ function run_test_with_server(server, ca
                            "test-breakpoints",
                            function (response, tabClient, threadClient) {
                              gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
-const test = async function() {
+const test = async function () {
   // Populate the `ScriptStore` so that we only test that the script
   // is added through `onNewScript`
   await getSources(gThreadClient);
 
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
   let source = gThreadClient.source(packet.frame.where.source);
   let location = {
     line: gDebuggee.line0 + 2
--- a/devtools/server/tests/unit/test_listsources-04.js
+++ b/devtools/server/tests/unit/test_listsources-04.js
@@ -16,27 +16,27 @@ function run_test() {
     // `rpc` method which talks to the main thread does not work.
     // run_test_with_server(WorkerDebuggerServer, do_test_finished);
     do_test_finished();
   });
   do_test_pending();
 }
 
 function run_test_with_server(server, cb) {
-  (async function() {
+  (async function () {
     initTestDebuggerServer(server);
     const debuggee = addTestGlobal("test-sources", server);
     const client = new DebuggerClient(server.connectPipe());
     await client.connect();
     const [,, threadClient] = await attachTestTabAndResume(client, "test-sources");
 
     await threadClient.reconfigure({ useSourceMaps: true });
     addSources(debuggee);
 
-    threadClient.getSources(async function(res) {
+    threadClient.getSources(async function (res) {
       Assert.equal(res.sources.length, 3, "3 sources exist");
 
       await threadClient.reconfigure({ useSourceMaps: false });
 
       threadClient.getSources(function (res) {
         Assert.equal(res.sources.length, 1, "1 source exist");
         client.close().then(cb);
       });
--- a/devtools/server/tests/unit/test_objectgrips-14.js
+++ b/devtools/server/tests/unit/test_objectgrips-14.js
@@ -36,17 +36,17 @@ function evalCode() {
         debugger;
       })();
     })();
 
     debugger;
   });
 }
 
-const testObjectGroup = async function() {
+const testObjectGroup = async function () {
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
 
   const ugh = packet.frame.environment.parent.parent.bindings.variables.ugh;
   const ughClient = await gThreadClient.pauseGrip(ugh.value);
 
   packet = await getPrototypeAndProperties(ughClient);
   packet = await resumeAndWaitForPause(gClient, gThreadClient);
 
--- a/devtools/server/tests/unit/test_objectgrips-15.js
+++ b/devtools/server/tests/unit/test_objectgrips-15.js
@@ -34,17 +34,17 @@ function evalCode() {
       ugh.push(i++);
       debugger;
     }
 
     Promise.resolve().then(foo).then(foo);
   });
 }
 
-const testObjectGroup = async function() {
+const testObjectGroup = async function () {
   let packet = await executeOnNextTickAndWaitForPause(evalCode, gClient);
 
   const ugh = packet.frame.environment.parent.bindings.variables.ugh;
   const ughClient = await gThreadClient.pauseGrip(ugh.value);
 
   packet = await getPrototypeAndProperties(ughClient);
 
   packet = await resumeAndWaitForPause(gClient, gThreadClient);
--- a/devtools/server/tests/unit/test_promise_state-01.js
+++ b/devtools/server/tests/unit/test_promise_state-01.js
@@ -12,17 +12,17 @@
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function () {
     attachTestTabAndResume(
       client, "test-promise-state",
       function (response, tabClient, threadClient) {
-        (async function() {
+        (async function () {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "pending");
 
--- a/devtools/server/tests/unit/test_promise_state-02.js
+++ b/devtools/server/tests/unit/test_promise_state-02.js
@@ -12,17 +12,17 @@
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function () {
     attachTestTabAndResume(
       client, "test-promise-state",
       function (response, tabClient, threadClient) {
-        (async function() {
+        (async function () {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "fulfilled");
           equal(grip.value.promiseState.value.actorID, packet.frame.arguments[0].actorID,
--- a/devtools/server/tests/unit/test_promise_state-03.js
+++ b/devtools/server/tests/unit/test_promise_state-03.js
@@ -12,17 +12,17 @@
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function () {
     attachTestTabAndResume(
       client, "test-promise-state",
       function (response, tabClient, threadClient) {
-        (async function() {
+        (async function () {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "rejected");
           equal(grip.value.promiseState.reason.actorID, packet.frame.arguments[0].actorID,
--- a/devtools/server/tests/unit/test_promises_actor_attach.js
+++ b/devtools/server/tests/unit/test_promises_actor_attach.js
@@ -5,17 +5,17 @@
 
 /**
  * Test that we can attach and detach to the PromisesActor under the correct
  * states.
  */
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("promises-actor-test");
   let chromeActors = await getChromeActors(client);
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
   await testAttach(client, chromeActors);
 
   let response = await listTabs(client);
--- a/devtools/server/tests/unit/test_promises_actor_exist.js
+++ b/devtools/server/tests/unit/test_promises_actor_exist.js
@@ -3,17 +3,17 @@
 /* eslint-disable no-shadow */
 
 "use strict";
 
 /**
  * Test that the PromisesActor exists in the TabActors and ChromeActors.
  */
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("promises-actor-test");
 
   let response = await listTabs(client);
   let targetTab = findTab(response.tabs, "promises-actor-test");
   ok(targetTab, "Found our target tab.");
 
   // Attach to the TabActor and check the response
   client.request({ to: targetTab.actor, type: "attach" }, response => {
--- a/devtools/server/tests/unit/test_promises_actor_list_promises.js
+++ b/devtools/server/tests/unit/test_promises_actor_list_promises.js
@@ -6,17 +6,17 @@
  * PromisesActor.
  */
 
 "use strict";
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 const SECRET = "MyLittleSecret";
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("promises-actor-test");
   let chromeActors = await getChromeActors(client);
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
   await testListPromises(client, chromeActors, v =>
     new Promise(resolve => resolve(v)));
 
--- a/devtools/server/tests/unit/test_promises_actor_onnewpromise.js
+++ b/devtools/server/tests/unit/test_promises_actor_onnewpromise.js
@@ -7,17 +7,17 @@
  */
 
 "use strict";
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("promises-actor-test");
   let chromeActors = await getChromeActors(client);
 
   ok(Promise.toString().includes("native code"), "Expect native DOM Promise");
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
   await testNewPromisesEvent(client, chromeActors,
--- a/devtools/server/tests/unit/test_promises_actor_onpromisesettled.js
+++ b/devtools/server/tests/unit/test_promises_actor_onpromisesettled.js
@@ -9,17 +9,17 @@
 "use strict";
 
 ChromeUtils.import("resource://testing-common/PromiseTestUtils.jsm", this);
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("promises-actor-test");
   let chromeActors = await getChromeActors(client);
 
   ok(Promise.toString().includes("native code"), "Expect native DOM Promise");
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
   await testPromisesSettled(client, chromeActors,
--- a/devtools/server/tests/unit/test_promises_client_getdependentpromises.js
+++ b/devtools/server/tests/unit/test_promises_client_getdependentpromises.js
@@ -6,17 +6,17 @@
  */
 
 "use strict";
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("test-promises-dependentpromises");
   let chromeActors = await getChromeActors(client);
   await attachTab(client, chromeActors);
 
   ok(Promise.toString().includes("native code"), "Expect native DOM Promise.");
 
   await testGetDependentPromises(client, chromeActors, () => {
     let p = new Promise(() => {});
--- a/devtools/server/tests/unit/test_promises_object_creationtimestamp.js
+++ b/devtools/server/tests/unit/test_promises_object_creationtimestamp.js
@@ -9,17 +9,17 @@
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
 ChromeUtils.defineModuleGetter(this, "Preferences",
                                "resource://gre/modules/Preferences.jsm");
 
-add_task(async function() {
+add_task(async function () {
   let timerPrecision = Preferences.get("privacy.reduceTimerPrecision");
   Preferences.set("privacy.reduceTimerPrecision", false);
 
   registerCleanupFunction(function () {
     Preferences.set("privacy.reduceTimerPrecision", timerPrecision);
   });
 
   let client = await startTestDebuggerServer("promises-object-test");
--- a/devtools/server/tests/unit/test_promises_object_timetosettle-01.js
+++ b/devtools/server/tests/unit/test_promises_object_timetosettle-01.js
@@ -7,17 +7,17 @@
  */
 
 "use strict";
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("test-promises-timetosettle");
   let chromeActors = await getChromeActors(client);
 
   ok(Promise.toString().includes("native code"), "Expect native DOM Promise.");
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
   await testGetTimeToSettle(client, chromeActors, () => {
--- a/devtools/server/tests/unit/test_promises_object_timetosettle-02.js
+++ b/devtools/server/tests/unit/test_promises_object_timetosettle-02.js
@@ -8,17 +8,17 @@
 
 "use strict";
 
 const { PromisesFront } = require("devtools/shared/fronts/promises");
 const { setTimeout } = ChromeUtils.import("resource://gre/modules/Timer.jsm", {});
 
 var EventEmitter = require("devtools/shared/event-emitter");
 
-add_task(async function() {
+add_task(async function () {
   let client = await startTestDebuggerServer("test-promises-timetosettle");
   let chromeActors = await getChromeActors(client);
   await attachTab(client, chromeActors);
 
   ok(Promise.toString().includes("native code"), "Expect native DOM Promise.");
 
   // We have to attach the chrome TabActor before playing with the PromiseActor
   await attachTab(client, chromeActors);
--- a/devtools/server/tests/unit/test_protocolSpec.js
+++ b/devtools/server/tests/unit/test_protocolSpec.js
@@ -1,11 +1,11 @@
 "use strict";
 
-const run_test = Test(async function() {
+const run_test = Test(async function () {
   initTestDebuggerServer();
   const connection = DebuggerServer.connectPipe();
   const client = Async(new DebuggerClient(connection));
 
   await client.connect();
 
   const response = await client.request({
     to: "root",
--- a/devtools/server/tests/unit/test_protocol_formtype.js
+++ b/devtools/server/tests/unit/test_protocol_formtype.js
@@ -136,17 +136,17 @@ var RootFront = protocol.FrontClassWithS
     this.manage(this);
   },
 
   form(v, ctx, detail) {
     this.lastForm = v;
   }
 });
 
-const run_test = Test(async function() {
+const run_test = Test(async function () {
   DebuggerServer.createRootActor = (conn => {
     return RootActor(conn);
   });
   DebuggerServer.init();
 
   const connection = DebuggerServer.connectPipe();
   const conn = new DebuggerClient(connection);
   const client = Async(conn);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-column-in-gcd-script.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     let global = testGlobal("test");
     loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
     Cu.forceGC(); Cu.forceGC(); Cu.forceGC();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-column-with-no-offsets-at-end-of-line.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-column-with-no-offsets-at-end-of-line.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-column-with-no-offsets-at-end-of-line.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_setBreakpoint-on-column.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-column.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-column.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line-in-gcd-script.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     let global = createTestGlobal("test");
     loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
     Cu.forceGC(); Cu.forceGC(); Cu.forceGC();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line-with-multiple-offsets.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line-with-multiple-statements.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line-with-no-offsets-in-gcd-script.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     let global = createTestGlobal("test");
     loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
     Cu.forceGC(); Cu.forceGC(); Cu.forceGC();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line-with-no-offsets.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line.js
@@ -1,14 +1,14 @@
 "use strict";
 
 var SOURCE_URL = getFileUrl("setBreakpoint-on-line.js");
 
 function run_test() {
-  return (async function() {
+  return (async function () {
     do_test_pending();
 
     DebuggerServer.registerModule("xpcshell-test/testactors");
     DebuggerServer.init(() => true);
 
     let global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
--- a/devtools/server/tests/unit/test_sourcemaps-03.js
+++ b/devtools/server/tests/unit/test_sourcemaps-03.js
@@ -23,17 +23,17 @@ function run_test() {
                              gThreadClient = threadClient;
                              test_simple_source_map();
                            });
   });
   do_test_pending();
 }
 
 function testBreakpointMapping(name, callback) {
-  (async function() {
+  (async function () {
     let response = await waitForPause(gThreadClient);
     Assert.equal(response.why.type, "debuggerStatement");
 
     const source = await getSource(gThreadClient, "http://example.com/www/js/" + name + ".js");
     response = await setBreakpoint(source, {
       // Setting the breakpoint on an empty line so that it is pushed down one
       // line and we can check the source mapped actualLocation later.
       line: 3
--- a/devtools/server/tests/unit/test_sourcemaps-16.js
+++ b/devtools/server/tests/unit/test_sourcemaps-16.js
@@ -16,17 +16,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-sourcemaps");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function () {
     attachTestThread(gClient, "test-sourcemaps", testSourcemap);
   });
   do_test_pending();
 }
 
-const testSourcemap = async function(threadResponse, tabClient, threadClient, tabResponse) {
+const testSourcemap = async function (threadResponse, tabClient, threadClient, tabResponse) {
     evalTestCode();
 
     const { sources } = await getSources(threadClient);
 
     for (let form of sources) {
       let sourceResponse = await getSourceContent(threadClient.source(form));
       ok(sourceResponse, "Should be able to get the source response");
       ok(sourceResponse.source, "Should have the source text as well");
--- a/devtools/server/tests/unit/test_stepping-07.js
+++ b/devtools/server/tests/unit/test_stepping-07.js
@@ -21,17 +21,17 @@ function run_test() {
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stepping", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect(testSteppingAndReturns);
 }
 
-const testSteppingAndReturns = async function() {
+const testSteppingAndReturns = async function () {
   const [attachResponse,, threadClient] = await attachTestTabAndResume(gClient,
                                                                        "test-stepping");
   ok(!attachResponse.error, "Should not get an error attaching");
 
   dumpn("Evaluating test code and waiting for first debugger statement");
   const dbgStmt1 = await executeOnNextTickAndWaitForPause(evaluateTestCode, gClient);
   equal(dbgStmt1.frame.where.line, 3,
         "Should be at debugger statement on line 3");
--- a/devtools/server/websocket-server.js
+++ b/devtools/server/websocket-server.js
@@ -75,17 +75,17 @@ function writeString(output, data) {
     wait();
   });
 }
 
 /**
  * Read HTTP request from async input stream.
  * @return Request line (string) and Map of header names and values.
  */
-const readHttpRequest = async function(input) {
+const readHttpRequest = async function (input) {
   let requestLine = "";
   let headers = new Map();
 
   while (true) {
     let line = await readLine(input);
     if (line.length == 0) {
       break;
     }
@@ -160,17 +160,17 @@ function computeKey(key) {
   let hash = new CryptoHash("sha1");
   hash.update(data, data.length);
   return hash.finish(true);
 }
 
 /**
  * Perform the server part of a WebSocket opening handshake on an incoming connection.
  */
-const serverHandshake = async function(input, output) {
+const serverHandshake = async function (input, output) {
   // Read the request
   let request = await readHttpRequest(input);
 
   try {
     // Check and extract info from the request
     let { acceptKey } = processRequest(request);
 
     // Send response headers
@@ -188,17 +188,17 @@ const serverHandshake = async function(i
 };
 
 /**
  * Accept an incoming WebSocket server connection.
  * Takes an established nsISocketTransport in the parameters.
  * Performs the WebSocket handshake and waits for the WebSocket to open.
  * Returns Promise with a WebSocket ready to send and receive messages.
  */
-const accept = async function(transport, input, output) {
+const accept = async function (transport, input, output) {
   await serverHandshake(input, output);
 
   let transportProvider = {
     setListener(upgradeListener) {
       // The onTransportAvailable callback shouldn't be called synchronously.
       executeSoon(() => {
         upgradeListener.onTransportAvailable(transport, input, output);
       });