Bug 1589001 - Rename (web)consoleClient variables and properties to webConsoleFront. r=Honza.
authorNicolas Chevobbe <nchevobbe@mozilla.com>
Thu, 17 Oct 2019 10:16:46 +0000
changeset 497993 d94a64a9633bd733d82043d11216b31df540baeb
parent 497992 a2873ee82d772091b21d4ac06a92d1787b63d23f
child 497994 fd648a1bcdcf029847452ea045ffb560564b5890
push id98197
push usernchevobbe@mozilla.com
push dateThu, 17 Oct 2019 13:46:46 +0000
treeherderautoland@d94a64a9633b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersHonza
bugs1589001
milestone71.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1589001 - Rename (web)consoleClient variables and properties to webConsoleFront. r=Honza. The webconsole actor now has an associated front for some time, but the naming of variables and properties didn't reflect that (most weren't updated and were still calling it a client). This patch tries to rename all those variables so it's more obvious we're dealing with an actual front. Differential Revision: https://phabricator.services.mozilla.com/D49401
devtools/client/netmonitor/src/connector/firefox-connector.js
devtools/client/netmonitor/src/connector/firefox-data-provider.js
devtools/client/netmonitor/src/har/har-automation.js
devtools/client/netmonitor/src/har/har-collector.js
devtools/client/netmonitor/test/browser_net_pause.js
devtools/client/scratchpad/scratchpad.js
devtools/client/webconsole/actions/autocomplete.js
devtools/client/webconsole/actions/input.js
devtools/client/webconsole/commands.js
devtools/client/webconsole/enhancers/message-cache-clearing.js
devtools/client/webconsole/webconsole-connection-proxy.js
devtools/client/webconsole/webconsole-ui.js
devtools/client/webconsole/webconsole-wrapper.js
devtools/server/tests/browser/browser_webextension_inspected_window.js
devtools/server/tests/mochitest/test_webconsole-node-grip.html
devtools/server/tests/mochitest/webconsole-helpers.js
devtools/shared/fronts/webconsole.js
devtools/shared/webconsole/test/browser/browser_commands_registration.js
devtools/shared/webconsole/test/browser/browser_network_longstring.js
devtools/shared/webconsole/test/common.js
devtools/shared/webconsole/test/test_basics.html
devtools/shared/webconsole/test/test_bug819670_getter_throws.html
devtools/shared/webconsole/test/test_cached_messages.html
devtools/shared/webconsole/test/test_commands_other.html
devtools/shared/webconsole/test/test_console_assert.html
devtools/shared/webconsole/test/test_console_group_styling.html
devtools/shared/webconsole/test/test_console_serviceworker.html
devtools/shared/webconsole/test/test_console_serviceworker_cached.html
devtools/shared/webconsole/test/test_console_styling.html
devtools/shared/webconsole/test/test_console_timestamp.html
devtools/shared/webconsole/test/test_console_worker.html
devtools/shared/webconsole/test/test_consoleapi.html
devtools/shared/webconsole/test/test_consoleapi_innerID.html
devtools/shared/webconsole/test/test_file_uri.html
devtools/shared/webconsole/test/test_jsterm.html
devtools/shared/webconsole/test/test_jsterm_autocomplete.html
devtools/shared/webconsole/test/test_jsterm_cd_iframe.html
devtools/shared/webconsole/test/test_jsterm_last_result.html
devtools/shared/webconsole/test/test_jsterm_queryselector.html
devtools/shared/webconsole/test/test_network_get.html
devtools/shared/webconsole/test/test_network_post.html
devtools/shared/webconsole/test/test_network_security-hpkp.html
devtools/shared/webconsole/test/test_network_security-hsts.html
devtools/shared/webconsole/test/test_nsiconsolemessage.html
devtools/shared/webconsole/test/test_object_actor.html
devtools/shared/webconsole/test/test_object_actor_native_getters.html
devtools/shared/webconsole/test/test_object_actor_native_getters_lenient_this.html
devtools/shared/webconsole/test/test_page_errors.html
devtools/shared/webconsole/test/test_throw.html
--- a/devtools/client/netmonitor/src/connector/firefox-connector.js
+++ b/devtools/client/netmonitor/src/connector/firefox-connector.js
@@ -53,20 +53,20 @@ class FirefoxConnector {
     this.actions = actions;
     this.getState = getState;
     this.tabTarget = connection.tabConnection.tabTarget;
     this.toolbox = connection.toolbox;
 
     // The owner object (NetMonitorAPI) received all events.
     this.owner = connection.owner;
 
-    this.webConsoleClient = this.tabTarget.activeConsole;
+    this.webConsoleFront = this.tabTarget.activeConsole;
 
     this.dataProvider = new FirefoxDataProvider({
-      webConsoleClient: this.webConsoleClient,
+      webConsoleFront: this.webConsoleFront,
       actions: this.actions,
       owner: this.owner,
     });
 
     // Register all listeners
     await this.addListeners();
 
     // Listener for `will-navigate` event is (un)registered outside
@@ -106,36 +106,36 @@ class FirefoxConnector {
     }
 
     if (this.tabTarget) {
       this.tabTarget.off("will-navigate", this.willNavigate);
       this.tabTarget.off("navigate", this.navigate);
       this.tabTarget = null;
     }
 
-    this.webConsoleClient = null;
+    this.webConsoleFront = null;
     this.dataProvider = null;
   }
 
   async pause() {
     await this.removeListeners();
   }
 
   async resume() {
     await this.addListeners();
   }
 
   async addListeners() {
     this.tabTarget.on("close", this.disconnect);
-    this.webConsoleClient.on("networkEvent", this.dataProvider.onNetworkEvent);
-    this.webConsoleClient.on(
+    this.webConsoleFront.on("networkEvent", this.dataProvider.onNetworkEvent);
+    this.webConsoleFront.on(
       "networkEventUpdate",
       this.dataProvider.onNetworkEventUpdate
     );
-    this.webConsoleClient.on("documentEvent", this.onDocEvent);
+    this.webConsoleFront.on("documentEvent", this.onDocEvent);
 
     // Support for WebSocket monitoring is currently hidden behind this pref.
     if (Services.prefs.getBoolPref("devtools.netmonitor.features.webSockets")) {
       try {
         // Initialize WebSocket front to intercept websocket traffic.
         this.webSocketFront = await this.tabTarget.getFront("webSocket");
         this.webSocketFront.startListening();
 
@@ -154,17 +154,17 @@ class FirefoxConnector {
         this.webSocketFront.on("frameSent", this.dataProvider.onFrameSent);
       } catch (e) {
         // Support for FF68 or older
       }
     }
 
     // The console actor supports listening to document events like
     // DOMContentLoaded and load.
-    await this.webConsoleClient.startListeners(["DocumentEvents"]);
+    await this.webConsoleFront.startListeners(["DocumentEvents"]);
   }
 
   removeListeners() {
     if (this.tabTarget) {
       this.tabTarget.off("close", this.disconnect);
       if (this.webSocketFront) {
         this.webSocketFront.off(
           "webSocketOpened",
@@ -176,26 +176,26 @@ class FirefoxConnector {
         );
         this.webSocketFront.off(
           "frameReceived",
           this.dataProvider.onFrameReceived
         );
         this.webSocketFront.off("frameSent", this.dataProvider.onFrameSent);
       }
     }
-    if (this.webConsoleClient) {
-      this.webConsoleClient.off(
+    if (this.webConsoleFront) {
+      this.webConsoleFront.off(
         "networkEvent",
         this.dataProvider.onNetworkEvent
       );
-      this.webConsoleClient.off(
+      this.webConsoleFront.off(
         "networkEventUpdate",
         this.dataProvider.onNetworkEventUpdate
       );
-      this.webConsoleClient.off("docEvent", this.onDocEvent);
+      this.webConsoleFront.off("docEvent", this.onDocEvent);
     }
   }
 
   enableActions(enable) {
     this.dataProvider.enableActions(enable);
   }
 
   willNavigate() {
@@ -247,17 +247,17 @@ class FirefoxConnector {
       panel.emit("reloaded");
     }
   }
 
   /**
    * Display any network events already in the cache.
    */
   displayCachedEvents() {
-    for (const networkInfo of this.webConsoleClient.getNetworkEvents()) {
+    for (const networkInfo of this.webConsoleFront.getNetworkEvents()) {
       // First add the request to the timeline.
       this.dataProvider.onNetworkEvent(networkInfo);
       // Then replay any updates already received.
       for (const updateType of networkInfo.updates) {
         this.dataProvider.onNetworkEventUpdate({
           packet: { updateType },
           networkInfo,
         });
@@ -280,54 +280,54 @@ class FirefoxConnector {
 
   /**
    * Send a HTTP request data payload
    *
    * @param {object} data data payload would like to sent to backend
    * @param {function} callback callback will be invoked after the request finished
    */
   sendHTTPRequest(data, callback) {
-    this.webConsoleClient.sendHTTPRequest(data).then(callback);
+    this.webConsoleFront.sendHTTPRequest(data).then(callback);
   }
 
   /**
    * Block future requests matching a filter.
    *
    * @param {object} filter request filter specifying what to block
    */
   blockRequest(filter) {
-    return this.webConsoleClient.blockRequest(filter);
+    return this.webConsoleFront.blockRequest(filter);
   }
 
   /**
    * Unblock future requests matching a filter.
    *
    * @param {object} filter request filter specifying what to unblock
    */
   unblockRequest(filter) {
-    return this.webConsoleClient.unblockRequest(filter);
+    return this.webConsoleFront.unblockRequest(filter);
   }
 
   /**
    * Updates the list of blocked URLs
    *
    * @param {object} urls An array of URL strings
    */
   setBlockedUrls(urls) {
-    return this.webConsoleClient.setBlockedUrls(urls);
+    return this.webConsoleFront.setBlockedUrls(urls);
   }
 
   /**
    * Set network preferences to control network flow
    *
    * @param {object} request request payload would like to sent to backend
    * @param {function} callback callback will be invoked after the request finished
    */
   setPreferences(request) {
-    return this.webConsoleClient.setPreferences(request);
+    return this.webConsoleFront.setPreferences(request);
   }
 
   /**
    * Triggers a specific "activity" to be performed by the frontend.
    * This can be, for example, triggering reloads or enabling/disabling cache.
    *
    * @param {number} type The activity type. See the ACTIVITY_TYPE const.
    * @return {object} A promise resolved once the activity finishes and the frontend
--- a/devtools/client/netmonitor/src/connector/firefox-data-provider.js
+++ b/devtools/client/netmonitor/src/connector/firefox-data-provider.js
@@ -16,23 +16,23 @@ const { fetchHeaders } = require("../uti
  * The object also keeps track of RDP requests in-progress,
  * so it's possible to determine whether all has been fetched
  * or not.
  */
 class FirefoxDataProvider {
   /**
    * Constructor for data provider
    *
-   * @param {Object} webConcoleClient represents the client object for Console actor.
+   * @param {Object} webConsoleFront represents the client object for Console actor.
    * @param {Object} actions set of actions fired during data fetching process
    * @params {Object} owner all events are fired on this object
    */
-  constructor({ webConsoleClient, actions, owner }) {
+  constructor({ webConsoleFront, actions, owner }) {
     // Options
-    this.webConsoleClient = webConsoleClient;
+    this.webConsoleFront = webConsoleFront;
     this.actions = actions || {};
     this.actionsEnabled = true;
     this.owner = owner;
 
     // Internal properties
     this.payloadQueue = new Map();
 
     // Map[key string => Promise] used by `requestData` to prevent requesting the same
@@ -321,32 +321,32 @@ class FirefoxDataProvider {
 
   /**
    * Fetches the network information packet from actor server
    *
    * @param {string} id request id
    * @return {object} networkInfo data packet
    */
   getNetworkRequest(id) {
-    return this.webConsoleClient.getNetworkRequest(id);
+    return this.webConsoleFront.getNetworkRequest(id);
   }
 
   /**
    * Fetches the full text of a LongString.
    *
    * @param {object|string} stringGrip
    *        The long string grip containing the corresponding actor.
    *        If you pass in a plain string (by accident or because you're lazy),
    *        then a promise of the same string is simply returned.
    * @return {object}
    *         A promise that is resolved when the full string contents
    *         are available, or rejected if something goes wrong.
    */
   getLongString(stringGrip) {
-    return this.webConsoleClient.getString(stringGrip).then(payload => {
+    return this.webConsoleFront.getString(stringGrip).then(payload => {
       this.emitForTests(EVENTS.LONGSTRING_RESOLVED, { payload });
       return payload;
     });
   }
 
   /**
    * The "networkEvent" message type handler.
    *
@@ -604,20 +604,20 @@ class FirefoxDataProvider {
       .replace(/([A-Z])/g, "_$1")
       .toUpperCase()}`;
 
     // Emit event that tell we just start fetching some data
     this.emitForTests(EVENTS[updatingEventName], actor);
 
     let response = await new Promise((resolve, reject) => {
       // Do a RDP request to fetch data from the actor.
-      if (typeof this.webConsoleClient[clientMethodName] === "function") {
+      if (typeof this.webConsoleFront[clientMethodName] === "function") {
         // Make sure we fetch the real actor data instead of cloned actor
         // e.g. CustomRequestPanel will clone a request with additional '-clone' actor id
-        this.webConsoleClient[clientMethodName](
+        this.webConsoleFront[clientMethodName](
           actor.replace("-clone", ""),
           res => {
             if (res.error) {
               reject(
                 new Error(
                   `Error while calling method ${clientMethodName}: ${
                     res.message
                   }`
--- a/devtools/client/netmonitor/src/har/har-automation.js
+++ b/devtools/client/netmonitor/src/har/har-automation.js
@@ -60,17 +60,17 @@ HarAutomation.prototype = {
   // Automation
 
   startMonitoring: function(client, callback) {
     if (!client) {
       return;
     }
 
     this.debuggerClient = client;
-    this.webConsoleClient = this.toolbox.target.activeConsole;
+    this.webConsoleFront = this.toolbox.target.activeConsole;
 
     this.tabWatcher = new TabWatcher(this.toolbox, this);
     this.tabWatcher.connect();
   },
 
   pageLoadBegin: function(response) {
     this.resetCollector();
   },
@@ -78,17 +78,17 @@ HarAutomation.prototype = {
   resetCollector: function() {
     if (this.collector) {
       this.collector.stop();
     }
 
     // A page is about to be loaded, start collecting HTTP
     // data from events sent from the backend.
     this.collector = new HarCollector({
-      webConsoleClient: this.webConsoleClient,
+      webConsoleFront: this.webConsoleFront,
       debuggerClient: this.debuggerClient,
     });
 
     this.collector.start();
   },
 
   /**
    * A page is done loading, export collected data. Note that
@@ -191,17 +191,17 @@ HarAutomation.prototype = {
       return jsonString;
     });
   },
 
   /**
    * Fetches the full text of a string.
    */
   getString: function(stringGrip) {
-    return this.webConsoleClient.getString(stringGrip);
+    return this.webConsoleFront.getString(stringGrip);
   },
 };
 
 // Helpers
 
 function TabWatcher(toolbox, listener) {
   this.target = toolbox.target;
   this.listener = listener;
--- a/devtools/client/netmonitor/src/har/har-collector.js
+++ b/devtools/client/netmonitor/src/har/har-collector.js
@@ -11,17 +11,17 @@ const trace = {
   log: function(...args) {},
 };
 
 /**
  * This object is responsible for collecting data related to all
  * HTTP requests executed by the page (including inner iframes).
  */
 function HarCollector(options) {
-  this.webConsoleClient = options.webConsoleClient;
+  this.webConsoleFront = options.webConsoleFront;
   this.debuggerClient = options.debuggerClient;
 
   this.onNetworkEvent = this.onNetworkEvent.bind(this);
   this.onNetworkEventUpdate = this.onNetworkEventUpdate.bind(this);
   this.onRequestHeaders = this.onRequestHeaders.bind(this);
   this.onRequestCookies = this.onRequestCookies.bind(this);
   this.onRequestPostData = this.onRequestPostData.bind(this);
   this.onResponseHeaders = this.onResponseHeaders.bind(this);
@@ -153,17 +153,17 @@ HarCollector.prototype = {
   getItems: function() {
     return this.items;
   },
 
   // Event Handlers
 
   onNetworkEvent: function(packet) {
     // Skip events from different console actors.
-    if (packet.from != this.webConsoleClient.actor) {
+    if (packet.from != this.webConsoleFront.actor) {
       return;
     }
 
     trace.log("HarCollector.onNetworkEvent; " + packet.type, packet);
 
     const { actor, startedDateTime, method, url, isXHR } = packet.eventActor;
     const startTime = Date.parse(startedDateTime);
 
@@ -282,29 +282,29 @@ HarCollector.prototype = {
       this.requests.push(request);
     }
 
     this.resetPageLoadTimeout();
   },
 
   getData: function(actor, method, callback) {
     return new Promise(resolve => {
-      if (!this.webConsoleClient[method]) {
+      if (!this.webConsoleFront[method]) {
         console.error("HarCollector.getData: ERROR Unknown method!");
         resolve();
       }
 
       const file = this.getFile(actor);
 
       trace.log(
         "HarCollector.getData; REQUEST " + method + ", " + file.url,
         file
       );
 
-      this.webConsoleClient[method](actor, response => {
+      this.webConsoleFront[method](actor, response => {
         trace.log(
           "HarCollector.getData; RESPONSE " + method + ", " + file.url,
           response
         );
         callback(response);
         resolve(response);
       });
     });
@@ -437,17 +437,17 @@ HarCollector.prototype = {
    *        The long string grip containing the corresponding actor.
    *        If you pass in a plain string (by accident or because you're lazy),
    *        then a promise of the same string is simply returned.
    * @return object Promise
    *         A promise that is resolved when the full string contents
    *         are available, or rejected if something goes wrong.
    */
   getString: function(stringGrip) {
-    const promise = this.webConsoleClient.getString(stringGrip);
+    const promise = this.webConsoleFront.getString(stringGrip);
     this.requests.push(promise);
     return promise;
   },
 };
 
 // Helpers
 
 /**
--- a/devtools/client/netmonitor/test/browser_net_pause.js
+++ b/devtools/client/netmonitor/test/browser_net_pause.js
@@ -75,14 +75,14 @@ async function performRequestAndWait(tab
   });
   await wait;
 }
 
 /**
  * Execute simple GET request
  */
 async function performPausedRequest(connector, tab, monitor) {
-  const wait = connector.connector.webConsoleClient.once("networkEvent");
+  const wait = connector.connector.webConsoleFront.once("networkEvent");
   await ContentTask.spawn(tab.linkedBrowser, SIMPLE_SJS, async function(url) {
     await content.wrappedJSObject.performRequests(url);
   });
   await wait;
 }
--- a/devtools/client/scratchpad/scratchpad.js
+++ b/devtools/client/scratchpad/scratchpad.js
@@ -549,23 +549,20 @@ var Scratchpad = {
       connection = ScratchpadTarget.consoleFor(this.target);
     } else if (this.executionContext == SCRATCHPAD_CONTEXT_CONTENT) {
       connection = ScratchpadTab.consoleFor(this.gBrowser.selectedTab);
     } else {
       connection = ScratchpadWindow.consoleFor(this.browserWindow);
     }
 
     const evalOptions = { url: this.uniqueName };
-    const { debuggerClient, webConsoleClient } = await connection;
+    const { debuggerClient, webConsoleFront } = await connection;
     this.debuggerClient = debuggerClient;
-    this.webConsoleClient = webConsoleClient;
-    const response = await webConsoleClient.evaluateJSAsync(
-      string,
-      evalOptions
-    );
+    this.webConsoleFront = webConsoleFront;
+    const response = await webConsoleFront.evaluateJSAsync(string, evalOptions);
 
     if (response.error) {
       throw new Error(response.error);
     } else if (response.exception != null) {
       return [string, response];
     } else {
       return [string, undefined, response.result];
     }
@@ -846,18 +843,17 @@ var Scratchpad = {
    *
    * @param any value
    *        The value to print.
    * @return Promise
    *         The promise that resolves after the value has been printed.
    */
   async _writePrimitiveAsComment(value) {
     if (value.type == "longString") {
-      const client = this.webConsoleClient;
-      const response = await client
+      const response = await this.webConsoleFront
         .longString(value)
         .substring(0, value.length);
       if (response.error) {
         reportError("display", response);
         throw new Error(response.error);
       } else {
         this.writeAsComment(response.substring);
       }
@@ -1901,17 +1897,17 @@ var Scratchpad = {
     this.editor = null;
 
     if (this._sidebar) {
       this._sidebar.destroy();
       this._sidebar = null;
     }
 
     scratchpadTargets = null;
-    this.webConsoleClient = null;
+    this.webConsoleFront = null;
     this.debuggerClient = null;
     this.initialized = false;
   },
 
   /**
    * Prompt to save scratchpad if it has unsaved changes.
    *
    * @param function aCallback
@@ -2153,17 +2149,17 @@ var Scratchpad = {
  */
 function ScratchpadTab(aTab) {
   this._tab = aTab;
 }
 
 var scratchpadTargets = new WeakMap();
 
 /**
- * Returns the object containing the DebuggerClient and WebConsoleClient for a
+ * Returns the object containing the DebuggerClient and WebConsoleFront for a
  * given tab or window.
  *
  * @param object aSubject
  *        The tab or window to obtain the connection for.
  * @return Promise
  *         The promise for the connection information.
  */
 ScratchpadTab.consoleFor = function consoleFor(aSubject) {
@@ -2199,17 +2195,17 @@ ScratchpadTab.prototype = {
           error: "timeout",
           message: Scratchpad.strings.GetStringFromName("connectionTimeout"),
         });
       }, REMOTE_TIMEOUT);
       try {
         const target = await this._attach(subject);
         clearTimeout(connectTimer);
         resolve({
-          webConsoleClient: target.activeConsole,
+          webConsoleFront: target.activeConsole,
           debuggerClient: target.client,
         });
       } catch (error) {
         reportError("attachConsole", error);
         reject(error);
       }
     });
 
@@ -2342,17 +2338,17 @@ ScratchpadSidebar.prototype = {
                 this._scratchpad.debuggerClient,
                 grip
               );
             },
             getObjectClient: grip => {
               return new ObjectClient(this._scratchpad.debuggerClient, grip);
             },
             getLongStringClient: actor => {
-              return this._scratchpad.webConsoleClient.longString(actor);
+              return this._scratchpad.webConsoleFront.longString(actor);
             },
             releaseActor: actor => {
               // Ignore release failure, since the object actor may have been already GC.
               this._scratchpad.debuggerClient.release(actor).catch(() => {});
             },
           });
         }
         this._update(obj).then(resolve);
--- a/devtools/client/webconsole/actions/autocomplete.js
+++ b/devtools/client/webconsole/actions/autocomplete.js
@@ -21,17 +21,20 @@ const {
  */
 function autocompleteUpdate(force, getterPath) {
   return ({ dispatch, getState, webConsoleUI, hud }) => {
     if (hud.inputHasSelection()) {
       return dispatch(autocompleteClear());
     }
 
     const inputValue = hud.getInputValue();
-    const { frameActor: frameActorId, client } = webConsoleUI.getFrameActor();
+    const {
+      frameActor: frameActorId,
+      webConsoleFront,
+    } = webConsoleUI.getFrameActor();
     const cursor = webConsoleUI.getInputCursor();
 
     const state = getState().autocomplete;
     const { cache } = state;
     if (
       !force &&
       (!inputValue || /^[a-zA-Z0-9_$]/.test(inputValue.substring(cursor)))
     ) {
@@ -71,17 +74,17 @@ function autocompleteUpdate(force, gette
         authorizedEvaluations = [getterPath];
       }
     }
 
     return dispatch(
       autocompleteDataFetch({
         input,
         frameActorId,
-        client,
+        webConsoleFront,
         authorizedEvaluations,
         force,
       })
     );
   };
 }
 
 /**
@@ -113,34 +116,34 @@ function generateRequestId() {
 
 /**
  * Action that fetch autocompletion data from the server.
  *
  * @param {Object} Object of the following shape:
  *        - {String} input: the expression that we want to complete.
  *        - {String} frameActorId: The id of the frame we want to autocomplete in.
  *        - {Boolean} force: true if the user forced an autocompletion (with Ctrl+Space).
- *        - {WebConsoleClient} client: The webconsole client.
+ *        - {WebConsoleFront} client: The webconsole front.
  *        - {Array} authorizedEvaluations: Array of the properties access which can be
  *                  executed by the engine.
  *                   Example: [["x", "myGetter"], ["x", "myGetter", "y", "glitter"]]
  *                  to retrieve properties of `x.myGetter.` and `x.myGetter.y.glitter`.
  */
 function autocompleteDataFetch({
   input,
   frameActorId,
   force,
-  client,
+  webConsoleFront,
   authorizedEvaluations,
 }) {
   return ({ dispatch, webConsoleUI }) => {
     const selectedNodeActor = webConsoleUI.getSelectedNodeActor();
     const id = generateRequestId();
     dispatch({ type: AUTOCOMPLETE_PENDING_REQUEST, id });
-    client
+    webConsoleFront
       .autocomplete(
         input,
         undefined,
         frameActorId,
         selectedNodeActor,
         authorizedEvaluations
       )
       .then(data => {
--- a/devtools/client/webconsole/actions/input.js
+++ b/devtools/client/webconsole/actions/input.js
@@ -67,23 +67,23 @@ function evaluateExpression(expression) 
     } catch (e) {
       console.warn("Error when calling getMappedExpression", e);
     }
 
     expression = mappedExpressionRes
       ? mappedExpressionRes.expression
       : expression;
 
-    const { frameActor, client } = webConsoleUI.getFrameActor();
+    const { frameActor, webConsoleFront } = webConsoleUI.getFrameActor();
 
     // Even if the evaluation fails,
     // we still need to pass the error response to onExpressionEvaluated.
     const onSettled = res => res;
 
-    const response = await client
+    const response = await webConsoleFront
       .evaluateJSAsync(expression, {
         frameActor,
         selectedNodeActor: webConsoleUI.getSelectedNodeActor(),
         mapped: mappedExpressionRes ? mappedExpressionRes.mapped : null,
       })
       .then(onSettled, onSettled);
 
     return dispatch(onExpressionEvaluated(response));
--- a/devtools/client/webconsole/commands.js
+++ b/devtools/client/webconsole/commands.js
@@ -11,17 +11,17 @@ class ConsoleCommands {
   constructor({ debuggerClient, proxy, threadFront, currentTarget }) {
     this.debuggerClient = debuggerClient;
     this.proxy = proxy;
     this.threadFront = threadFront;
     this.currentTarget = currentTarget;
   }
 
   evaluateJSAsync(expression, options) {
-    return this.proxy.webConsoleClient.evaluateJSAsync(expression, options);
+    return this.proxy.webConsoleFront.evaluateJSAsync(expression, options);
   }
 
   createObjectClient(object) {
     return new ObjectClient(this.debuggerClient, object);
   }
 
   createLongStringClient(object) {
     return new LongStringClient(this.debuggerClient, object);
--- a/devtools/client/webconsole/enhancers/message-cache-clearing.js
+++ b/devtools/client/webconsole/enhancers/message-cache-clearing.js
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 "use strict";
 
 const { MESSAGES_CLEAR } = require("devtools/client/webconsole/constants");
 
 /**
  * This enhancer is responsible for clearing the messages caches using the
- * webconsoleClient when the user clear the messages (either by direct UI action, or via
+ * webconsoleFront when the user clear the messages (either by direct UI action, or via
  * `console.clear()`).
  */
 function enableMessagesCacheClearing(webConsoleUI) {
   return next => (reducer, initialState, enhancer) => {
     function messagesCacheClearingEnhancer(state, action) {
       state = reducer(state, action);
 
       if (webConsoleUI && action.type === MESSAGES_CLEAR) {
--- a/devtools/client/webconsole/webconsole-connection-proxy.js
+++ b/devtools/client/webconsole/webconsole-connection-proxy.js
@@ -62,18 +62,18 @@ class WebConsoleConnectionProxy {
       return this._connecter;
     }
 
     this.target.on("will-navigate", this._onTabWillNavigate);
     this.target.on("navigate", this._onTabNavigated);
 
     const connection = (async () => {
       this.client = this.target.client;
-      this.webConsoleClient = await this.target.getFront("console");
-      this._addWebConsoleClientEventListeners();
+      this.webConsoleFront = await this.target.getFront("console");
+      this._addWebConsoleFrontEventListeners();
       await this._attachConsole();
 
       // There is no way to view response bodies from the Browser Console, so do
       // not waste the memory.
       const saveBodies =
         !this.webConsoleUI.isBrowserConsole &&
         Services.prefs.getBoolPref(
           "devtools.netmonitor.saveRequestAndResponseBodies"
@@ -81,17 +81,17 @@ class WebConsoleConnectionProxy {
       await this.webConsoleUI.setSaveRequestAndResponseBodies(saveBodies);
 
       const cachedMessages = await this._getCachedMessages();
       const networkMessages = this._getNetworkMessages();
       const messages = cachedMessages.concat(networkMessages);
       messages.sort((a, b) => a.timeStamp - b.timeStamp);
       this.dispatchMessagesAdd(messages);
 
-      if (!this.webConsoleClient.hasNativeConsoleAPI) {
+      if (!this.webConsoleFront.hasNativeConsoleAPI) {
         await this.webConsoleUI.logWarningAboutReplacedAPI();
       }
     })();
 
     let timeoutId;
     const connectionTimeout = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         reject({
@@ -121,70 +121,70 @@ class WebConsoleConnectionProxy {
     const listeners = ["PageError", "ConsoleAPI", "NetworkActivity"];
     // Enable the forwarding of console messages to the parent process
     // when we open the Browser Console or Toolbox without fission support. If Fission
     // is enabled, we don't use the ContentProcessMessages listener, but attach to the
     // content processes directly.
     if (this.needContentProcessMessagesListener) {
       listeners.push("ContentProcessMessages");
     }
-    return this.webConsoleClient.startListeners(listeners);
+    return this.webConsoleFront.startListeners(listeners);
   }
 
   /**
    * Sets all the relevant event listeners on the webconsole client.
    *
    * @private
    */
-  _addWebConsoleClientEventListeners() {
-    this.webConsoleClient.on("networkEvent", this._onNetworkEvent);
-    this.webConsoleClient.on("networkEventUpdate", this._onNetworkEventUpdate);
-    this.webConsoleClient.on("logMessage", this._onLogMessage);
-    this.webConsoleClient.on("pageError", this._onPageError);
-    this.webConsoleClient.on("consoleAPICall", this._onConsoleAPICall);
-    this.webConsoleClient.on(
+  _addWebConsoleFrontEventListeners() {
+    this.webConsoleFront.on("networkEvent", this._onNetworkEvent);
+    this.webConsoleFront.on("networkEventUpdate", this._onNetworkEventUpdate);
+    this.webConsoleFront.on("logMessage", this._onLogMessage);
+    this.webConsoleFront.on("pageError", this._onPageError);
+    this.webConsoleFront.on("consoleAPICall", this._onConsoleAPICall);
+    this.webConsoleFront.on(
       "lastPrivateContextExited",
       this._onLastPrivateContextExited
     );
-    this.webConsoleClient.on(
+    this.webConsoleFront.on(
       "clearLogpointMessages",
       this._clearLogpointMessages
     );
   }
 
   /**
    * Remove all set event listeners on the webconsole client.
    *
    * @private
    */
-  _removeWebConsoleClientEventListeners() {
-    this.webConsoleClient.off("networkEvent", this._onNetworkEvent);
-    this.webConsoleClient.off("networkEventUpdate", this._onNetworkEventUpdate);
-    this.webConsoleClient.off("logMessage", this._onLogMessage);
-    this.webConsoleClient.off("pageError", this._onPageError);
-    this.webConsoleClient.off("consoleAPICall", this._onConsoleAPICall);
-    this.webConsoleClient.off(
+  _removeWebConsoleFrontEventListeners() {
+    this.webConsoleFront.off("networkEvent", this._onNetworkEvent);
+    this.webConsoleFront.off("networkEventUpdate", this._onNetworkEventUpdate);
+    this.webConsoleFront.off("logMessage", this._onLogMessage);
+    this.webConsoleFront.off("pageError", this._onPageError);
+    this.webConsoleFront.off("consoleAPICall", this._onConsoleAPICall);
+    this.webConsoleFront.off(
       "lastPrivateContextExited",
       this._onLastPrivateContextExited
     );
-    this.webConsoleClient.off(
+    this.webConsoleFront.off(
       "clearLogpointMessages",
       this._clearLogpointMessages
     );
   }
 
   /**
    * Get cached messages from the server.
    *
    * @private
    * @returns A Promise that resolves with the cached messages, or reject if something
    *          went wront.
    */
   async _getCachedMessages() {
-    const response = await this.webConsoleClient.getCachedMessages([
+    const response = await this.webConsoleFront.getCachedMessages([
       "PageError",
       "ConsoleAPI",
     ]);
 
     if (response.error) {
       throw new Error(
         `Web Console getCachedMessages error: ${response.error} ${
           response.message
@@ -197,17 +197,17 @@ class WebConsoleConnectionProxy {
 
   /**
    * Get network messages from the server.
    *
    * @private
    * @returns An array of network messages.
    */
   _getNetworkMessages() {
-    return Array.from(this.webConsoleClient.getNetworkEvents());
+    return Array.from(this.webConsoleFront.getNetworkEvents());
   }
 
   /**
    * The "pageError" message type handler. We redirect any page errors to the UI
    * for displaying.
    *
    * @private
    * @param object packet
@@ -372,18 +372,18 @@ class WebConsoleConnectionProxy {
    * @return object
    *         A promise object that is resolved when disconnect completes.
    */
   disconnect() {
     if (!this.client) {
       return;
     }
 
-    this._removeWebConsoleClientEventListeners();
+    this._removeWebConsoleFrontEventListeners();
     this.target.off("will-navigate", this._onTabWillNavigate);
     this.target.off("navigate", this._onTabNavigated);
 
     this.client = null;
-    this.webConsoleClient = null;
+    this.webConsoleFront = null;
   }
 }
 
 exports.WebConsoleConnectionProxy = WebConsoleConnectionProxy;
--- a/devtools/client/webconsole/webconsole-ui.js
+++ b/devtools/client/webconsole/webconsole-ui.js
@@ -65,27 +65,27 @@ class WebConsoleUI {
     this._listProcessesAndCreateProxies = this._listProcessesAndCreateProxies.bind(
       this
     );
 
     EventEmitter.decorate(this);
   }
 
   /**
-   * Getter for the debugger WebConsoleClient.
+   * Getter for the WebConsoleFront.
    * @type object
    */
-  get webConsoleClient() {
+  get webConsoleFront() {
     const proxy = this.getProxy();
 
     if (!proxy) {
       return null;
     }
 
-    return proxy.webConsoleClient;
+    return proxy.webConsoleFront;
   }
 
   /**
    * Return the main target proxy, i.e. the proxy for MainProcessTarget in BrowserConsole,
    * and the proxy for the target passed from the Toolbox to WebConsole.
    *
    * @returns {WebConsoleConnectionProxy}
    */
@@ -107,17 +107,17 @@ class WebConsoleUI {
 
     if (this.additionalProxies) {
       proxies = proxies.concat(this.additionalProxies);
     }
 
     // Ignore Fronts that are already destroyed
     if (filterDisconnectedProxies) {
       proxies = proxies.filter(proxy => {
-        return proxy.webConsoleClient && !!proxy.webConsoleClient.actorID;
+        return proxy.webConsoleFront && !!proxy.webConsoleFront.actorID;
       });
     }
 
     return proxies;
   }
 
   /**
    * Initialize the WebConsoleUI instance.
@@ -233,23 +233,23 @@ class WebConsoleUI {
     if (clearStorage) {
       this.clearMessagesCache();
     }
     this.emit("messages-cleared");
   }
 
   clearNetworkRequests() {
     for (const proxy of this.getAllProxies()) {
-      proxy.webConsoleClient.clearNetworkRequests();
+      proxy.webConsoleFront.clearNetworkRequests();
     }
   }
 
   clearMessagesCache() {
     for (const proxy of this.getAllProxies()) {
-      proxy.webConsoleClient.clearMessagesCache();
+      proxy.webConsoleFront.clearMessagesCache();
     }
   }
 
   /**
    * Remove all of the private messages from the Web Console output.
    *
    * This method emits the "private-messages-cleared" notification.
    */
@@ -286,28 +286,28 @@ class WebConsoleUI {
 
   /**
    * Setter for saving of network request and response bodies.
    *
    * @param boolean value
    *        The new value you want to set.
    */
   async setSaveRequestAndResponseBodies(value) {
-    if (!this.webConsoleClient) {
+    if (!this.webConsoleFront) {
       // Don't continue if the webconsole disconnected.
       return null;
     }
 
     const newValue = !!value;
     const toSet = {
       "NetworkMonitor.saveRequestAndResponseBodies": newValue,
     };
 
     // Make sure the web console client connection is established first.
-    return this.webConsoleClient.setPreferences(toSet);
+    return this.webConsoleFront.setPreferences(toSet);
   }
 
   /**
    * Connect to the server using the remote debugging protocol.
    *
    * @private
    * @return object
    *         A promise object that is resolved/reject based on the proxies connections.
@@ -502,24 +502,21 @@ class WebConsoleUI {
   }
 
   /**
    * @param {String} expression
    * @param {Object} options
    * @returns {Promise}
    */
   evaluateJSAsync(expression, options) {
-    return this.getProxy().webConsoleClient.evaluateJSAsync(
-      expression,
-      options
-    );
+    return this.getProxy().webConsoleFront.evaluateJSAsync(expression, options);
   }
 
   getLongString(grip) {
-    this.getProxy().webConsoleClient.getString(grip);
+    this.getProxy().webConsoleFront.getString(grip);
   }
 
   /**
    * Sets the focus to JavaScript input field when the web console tab is
    * selected or when there is a split console present.
    * @private
    */
   _onPanelSelected() {
@@ -568,37 +565,36 @@ class WebConsoleUI {
   attachRef(id, node) {
     this[id] = node;
   }
 
   /**
    * Retrieve the FrameActor ID given a frame depth, or the selected one if no
    * frame depth given.
    *
-   * @return { frameActor: String|null, client: Object }:
+   * @return { frameActor: String|null, webConsoleFront: WebConsoleFront }:
    *         frameActor is the FrameActor ID for the given frame depth
    *         (or the selected frame if it exists), null if no frame was found.
-   *         client is the WebConsole client for the thread the frame is
-   *         associated with.
+   *         webConsoleFront is the front for the thread the frame is associated with.
    */
   getFrameActor() {
     const state = this.hud.getDebuggerFrames();
     if (!state) {
-      return { frameActor: null, client: this.webConsoleClient };
+      return { frameActor: null, webConsoleFront: this.webConsoleFront };
     }
 
     const grip = state.frames[state.selected];
 
     if (!grip) {
-      return { frameActor: null, client: this.webConsoleClient };
+      return { frameActor: null, webConsoleFront: this.webConsoleFront };
     }
 
     return {
       frameActor: grip.actor,
-      client: state.target.activeConsole,
+      webConsoleFront: state.target.activeConsole,
     };
   }
 
   getSelectedNodeActor() {
     const inspectorSelection = this.hud.getInspectorSelection();
     if (inspectorSelection && inspectorSelection.nodeFront) {
       return inspectorSelection.nodeFront.actorID;
     }
--- a/devtools/client/webconsole/webconsole-wrapper.js
+++ b/devtools/client/webconsole/webconsole-wrapper.js
@@ -66,23 +66,23 @@ class WebConsoleWrapper {
     this.throttledDispatchPromise = null;
     this.telemetry = new Telemetry();
   }
 
   async init() {
     const { webConsoleUI } = this;
     const debuggerClient = this.hud.currentTarget.client;
 
-    const webConsoleClient = await this.hud.currentTarget.getFront("console");
+    const webConsoleFront = await this.hud.currentTarget.getFront("console");
 
     this.networkDataProvider = new DataProvider({
       actions: {
         updateRequest: (id, data) => this.batchedRequestUpdates({ id, data }),
       },
-      webConsoleClient,
+      webConsoleFront,
     });
 
     return new Promise(resolve => {
       const commands = new ConsoleCommands({
         debuggerClient,
         proxy: webConsoleUI.getProxy(),
         threadFront: this.toolbox && this.toolbox.threadFront,
         currentTarget: this.hud.currentTarget,
--- a/devtools/server/tests/browser/browser_webextension_inspected_window.js
+++ b/devtools/server/tests/browser/browser_webextension_inspected_window.js
@@ -23,25 +23,25 @@ async function setup(pageUrl) {
     addonId: extension.id,
   };
 
   const target = await addTabTarget(pageUrl);
 
   await target.attach();
 
   const { client } = target;
-  const consoleClient = target.activeConsole;
+  const webConsoleFront = target.activeConsole;
   const inspectedWindowFront = await target.getFront(
     "webExtensionInspectedWindow"
   );
 
   return {
     client,
     target,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
   };
 }
 
 async function teardown({ client, extension }) {
   await client.close();
@@ -123,22 +123,22 @@ add_task(async function test_successfull
 });
 
 add_task(async function test_successfull_inspectedWindowEval_resultAsGrip() {
   const {
     client,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
-    consoleClient,
+    webConsoleFront,
   } = await setup(MAIN_DOMAIN);
 
   let result = await inspectedWindowFront.eval(fakeExtCallerInfo, "window", {
     evalResultAsGrip: true,
-    toolboxConsoleActorID: consoleClient.actor,
+    toolboxConsoleActorID: webConsoleFront.actor,
   });
 
   ok(result.valueGrip, "Got a result from inspectedWindow eval");
   ok(result.valueGrip.actor, "Got a object actor as expected");
   is(result.valueGrip.type, "object", "Got a value grip of type object");
   is(
     result.valueGrip.class,
     "Window",
@@ -319,17 +319,17 @@ add_task(async function test_exception_i
   );
 
   await teardown({ client, extension });
 });
 
 add_task(async function test_exception_inspectedWindowReload() {
   const {
     client,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
     target,
   } = await setup(`${TEST_RELOAD_URL}?test=cache`);
 
   // Test reload with bypassCache=false.
 
@@ -340,114 +340,114 @@ add_task(async function test_exception_i
 
   ok(
     !reloadResult,
     "Got the expected undefined result from inspectedWindow reload"
   );
 
   await waitForNoBypassCacheReload;
 
-  const noBypassCacheEval = await consoleClient.evaluateJS(
+  const noBypassCacheEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     noBypassCacheEval.result,
     "empty cache headers",
     "Got the expected result with reload forceBypassCache=false"
   );
 
   // Test reload with bypassCache=true.
 
   const waitForForceBypassCacheReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, { ignoreCache: true });
 
   await waitForForceBypassCacheReload;
 
-  const forceBypassCacheEval = await consoleClient.evaluateJS(
+  const forceBypassCacheEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     forceBypassCacheEval.result,
     "no-cache:no-cache",
     "Got the expected result with reload forceBypassCache=true"
   );
 
   await teardown({ client, extension });
 });
 
 add_task(async function test_exception_inspectedWindowReload_customUserAgent() {
   const {
     client,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
     target,
   } = await setup(`${TEST_RELOAD_URL}?test=user-agent`);
 
   // Test reload with custom userAgent.
 
   const waitForCustomUserAgentReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {
     userAgent: "Customized User Agent",
   });
 
   await waitForCustomUserAgentReload;
 
-  const customUserAgentEval = await consoleClient.evaluateJS(
+  const customUserAgentEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     customUserAgentEval.result,
     "Customized User Agent",
     "Got the expected result on reload with a customized userAgent"
   );
 
   // Test reload with no custom userAgent.
 
   const waitForNoCustomUserAgentReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {});
 
   await waitForNoCustomUserAgentReload;
 
-  const noCustomUserAgentEval = await consoleClient.evaluateJS(
+  const noCustomUserAgentEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     noCustomUserAgentEval.result,
     window.navigator.userAgent,
     "Got the expected result with reload without a customized userAgent"
   );
 
   await teardown({ client, extension });
 });
 
 add_task(async function test_exception_inspectedWindowReload_injectedScript() {
   const {
     client,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
     target,
   } = await setup(`${TEST_RELOAD_URL}?test=injected-script&frames=3`);
 
   // Test reload with an injectedScript.
 
   const waitForInjectedScriptReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {
     injectedScript: `new ${injectedScript}`,
   });
   await waitForInjectedScriptReload;
 
-  const injectedScriptEval = await consoleClient.evaluateJS(
+  const injectedScriptEval = await webConsoleFront.evaluateJS(
     `(${collectEvalResults})()`
   );
 
   const expectedResult = new Array(5).fill("injected script executed first");
 
   SimpleTest.isDeeply(
     JSON.parse(injectedScriptEval.result),
     expectedResult,
@@ -455,17 +455,17 @@ add_task(async function test_exception_i
   );
 
   // Test reload without an injectedScript.
 
   const waitForNoInjectedScriptReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {});
   await waitForNoInjectedScriptReload;
 
-  const noInjectedScriptEval = await consoleClient.evaluateJS(
+  const noInjectedScriptEval = await webConsoleFront.evaluateJS(
     `(${collectEvalResults})()`
   );
 
   const newExpectedResult = new Array(5).fill("injected script NOT executed");
 
   SimpleTest.isDeeply(
     JSON.parse(noInjectedScriptEval.result),
     newExpectedResult,
@@ -473,17 +473,17 @@ add_task(async function test_exception_i
   );
 
   await teardown({ client, extension });
 });
 
 add_task(async function test_exception_inspectedWindowReload_multiple_calls() {
   const {
     client,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
     target,
   } = await setup(`${TEST_RELOAD_URL}?test=user-agent`);
 
   // Test reload with custom userAgent three times (and then
   // check that only the first one has affected the page reload.
@@ -494,50 +494,50 @@ add_task(async function test_exception_i
     userAgent: "Customized User Agent 1",
   });
   inspectedWindowFront.reload(fakeExtCallerInfo, {
     userAgent: "Customized User Agent 2",
   });
 
   await waitForCustomUserAgentReload;
 
-  const customUserAgentEval = await consoleClient.evaluateJS(
+  const customUserAgentEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     customUserAgentEval.result,
     "Customized User Agent 1",
     "Got the expected result on reload with a customized userAgent"
   );
 
   // Test reload with no custom userAgent.
 
   const waitForNoCustomUserAgentReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {});
 
   await waitForNoCustomUserAgentReload;
 
-  const noCustomUserAgentEval = await consoleClient.evaluateJS(
+  const noCustomUserAgentEval = await webConsoleFront.evaluateJS(
     "document.body.textContent"
   );
 
   is(
     noCustomUserAgentEval.result,
     window.navigator.userAgent,
     "Got the expected result with reload without a customized userAgent"
   );
 
   await teardown({ client, extension });
 });
 
 add_task(async function test_exception_inspectedWindowReload_stopped() {
   const {
     client,
-    consoleClient,
+    webConsoleFront,
     inspectedWindowFront,
     extension,
     fakeExtCallerInfo,
     target,
   } = await setup(`${TEST_RELOAD_URL}?test=injected-script&frames=3`);
 
   // Test reload on a page that calls window.stop() immediately during the page loading
 
@@ -552,17 +552,17 @@ add_task(async function test_exception_i
 
   info("Starting a reload with an injectedScript");
   const waitForInjectedScriptReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {
     injectedScript: `new ${injectedScript}`,
   });
   await waitForInjectedScriptReload;
 
-  const injectedScriptEval = await consoleClient.evaluateJS(
+  const injectedScriptEval = await webConsoleFront.evaluateJS(
     `(${collectEvalResults})()`
   );
 
   // The page should have stopped during the reload and only one injected script
   // is expected.
   const expectedResult = new Array(1).fill("injected script executed first");
 
   SimpleTest.isDeeply(
@@ -573,17 +573,17 @@ add_task(async function test_exception_i
 
   // Reload again with no options.
 
   info("Reload the tab again without any reload options");
   const waitForNoInjectedScriptReload = waitForNextTabNavigated(target);
   await inspectedWindowFront.reload(fakeExtCallerInfo, {});
   await waitForNoInjectedScriptReload;
 
-  const noInjectedScriptEval = await consoleClient.evaluateJS(
+  const noInjectedScriptEval = await webConsoleFront.evaluateJS(
     `(${collectEvalResults})()`
   );
 
   // The page should have stopped during the reload and no injected script should
   // have been executed during this second reload (or it would mean that the previous
   // customized reload was still pending and has wrongly affected the second reload)
   const newExpectedResult = new Array(1).fill("injected script NOT executed");
 
--- a/devtools/server/tests/mochitest/test_webconsole-node-grip.html
+++ b/devtools/server/tests/mochitest/test_webconsole-node-grip.html
@@ -11,52 +11,52 @@
 
 const TEST_URL = "data:text/html,<html><body>Hello</body></html>";
 
 window.onload = async function() {
   SimpleTest.waitForExplicitFinish();
 
   try {
     const {
-      consoleClient,
+      webConsoleFront,
     } = await attachURL(TEST_URL);
-    await testNotInTreeElementNode(consoleClient);
-    await testInTreeElementNode(consoleClient);
-    await testNotInTreeTextNode(consoleClient);
-    await testInTreeTextNode(consoleClient);
+    await testNotInTreeElementNode(webConsoleFront);
+    await testInTreeElementNode(webConsoleFront);
+    await testNotInTreeTextNode(webConsoleFront);
+    await testInTreeTextNode(webConsoleFront);
   } catch (e) {
     ok(false, `Error thrown: ${e.message}`);
   }
   SimpleTest.finish();
 };
 
-async function testNotInTreeElementNode(consoleClient) {
+async function testNotInTreeElementNode(webConsoleFront) {
   info("Testing isConnected property on a ElementNode not in the DOM tree");
-  const {result} = await consoleClient.evaluateJS("document.createElement(\"div\")");
+  const {result} = await webConsoleFront.evaluateJS("document.createElement(\"div\")");
   is(result.preview.isConnected, false,
     "isConnected is false since we only created the element");
 }
 
-async function testInTreeElementNode(consoleClient) {
+async function testInTreeElementNode(webConsoleFront) {
   info("Testing isConnected property on a ElementNode in the DOM tree");
-  const {result} = await consoleClient.evaluateJS("document.body");
+  const {result} = await webConsoleFront.evaluateJS("document.body");
   is(result.preview.isConnected, true,
     "isConnected is true as expected, since the element was retrieved from the DOM tree");
 }
 
-async function testNotInTreeTextNode(consoleClient) {
+async function testNotInTreeTextNode(webConsoleFront) {
   info("Testing isConnected property on a TextNode not in the DOM tree");
-  const {result} = await consoleClient.evaluateJS("document.createTextNode(\"Hello\")");
+  const {result} = await webConsoleFront.evaluateJS("document.createTextNode(\"Hello\")");
   is(result.preview.isConnected, false,
     "isConnected is false since we only created the element");
 }
 
-async function testInTreeTextNode(consoleClient) {
+async function testInTreeTextNode(webConsoleFront) {
   info("Testing isConnected property on a TextNode in the DOM tree");
-  const {result} = await consoleClient.evaluateJS("document.body.firstChild");
+  const {result} = await webConsoleFront.evaluateJS("document.body.firstChild");
   is(result.preview.isConnected, true,
     "isConnected is true as expected, since the element was retrieved from the DOM tree");
 }
 
   </script>
 </head>
 <body>
   <p id="display"></p>
--- a/devtools/server/tests/mochitest/webconsole-helpers.js
+++ b/devtools/server/tests/mochitest/webconsole-helpers.js
@@ -25,26 +25,26 @@ if (!DebuggerServer.initialized) {
  * Open a tab, load the url, find the tab with the debugger server,
  * and attach the console to it.
  *
  * @param {string} url : url to navigate to
  * @return {Promise} Promise resolving when the console is attached.
  *         The Promise resolves with an object containing :
  *           - tab: the attached tab
  *           - targetFront: the target front
- *           - consoleClient: the console client
+ *           - webConsoleFront: the console front
  *           - cleanup: a generator function which can be called to close
  *             the opened tab and disconnect its debugger client.
  */
 async function attachURL(url) {
   const tab = await addTab(url);
   const target = await TargetFactory.forTab(tab);
   await target.attach();
   return {
-    consoleClient: target.activeConsole,
+    webConsoleFront: target.activeConsole,
   };
 }
 
 /**
  * Naive implementaion of addTab working from a mochitest-chrome test.
  */
 async function addTab(url) {
   const { gBrowser } = Services.wm.getMostRecentWindow("navigator:browser");
--- a/devtools/shared/fronts/webconsole.js
+++ b/devtools/shared/fronts/webconsole.js
@@ -8,17 +8,17 @@ const DevToolsUtils = require("devtools/
 const LongStringClient = require("devtools/shared/client/long-string-client");
 const {
   FrontClassWithSpec,
   registerFront,
 } = require("devtools/shared/protocol");
 const { webconsoleSpec } = require("devtools/shared/specs/webconsole");
 
 /**
- * A WebConsoleClient is used as a front end for the WebConsoleActor that is
+ * A WebConsoleFront is used as a front end for the WebConsoleActor that is
  * created on the server, hiding implementation details.
  *
  * @param object client
  *        The DebuggerClient instance we live for.
  */
 class WebConsoleFront extends FrontClassWithSpec(webconsoleSpec) {
   constructor(client, targetFront, parentFront) {
     super(client, targetFront, parentFront);
@@ -459,17 +459,17 @@ class WebConsoleFront extends FrontClass
     }
 
     const client = new LongStringClient(this._client, grip);
     this._longStrings[grip.actor] = client;
     return client;
   }
 
   /**
-   * Close the WebConsoleClient.
+   * Close the WebConsoleFront.
    *
    */
   destroy() {
     if (!this._client) {
       return null;
     }
     this.off("evaluationResult", this.onEvaluationResult);
     this.off("serverNetworkEvent", this.onNetworkEvent);
--- a/devtools/shared/webconsole/test/browser/browser_commands_registration.js
+++ b/devtools/shared/webconsole/test/browser/browser_commands_registration.js
@@ -4,69 +4,69 @@
 "use strict";
 
 // Test for Web Console commands registration.
 
 add_task(async function() {
   const tab = await addTab("data:text/html,<div id=quack></div>");
   const target = await getTargetForTab(tab);
 
-  const consoleClient = target.activeConsole;
+  const webConsoleFront = target.activeConsole;
 
   // Fetch WebConsoleCommands so that it is available for next Content Tasks
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     const { require } = ChromeUtils.import(
       "resource://devtools/shared/Loader.jsm"
     );
     const {
       WebConsoleCommands,
     } = require("devtools/server/actors/webconsole/utils");
 
     // Bind the symbol on this in order to make it available for next tasks
     this.WebConsoleCommands = WebConsoleCommands;
   });
 
-  await registerNewCommand(consoleClient);
-  await wrapCommand(consoleClient);
-  await unregisterCommand(consoleClient);
-  await registerAccessor(consoleClient);
-  await unregisterAfterOverridingTwice(consoleClient);
+  await registerNewCommand(webConsoleFront);
+  await wrapCommand(webConsoleFront);
+  await unregisterCommand(webConsoleFront);
+  await registerAccessor(webConsoleFront);
+  await unregisterAfterOverridingTwice(webConsoleFront);
 });
 
-async function evaluateJSAndCheckResult(consoleClient, input, expected) {
-  const response = await consoleClient.evaluateJS(input);
+async function evaluateJSAndCheckResult(webConsoleFront, input, expected) {
+  const response = await webConsoleFront.evaluateJS(input);
   checkObject(response, expected);
 }
 
-async function registerNewCommand(consoleClient) {
+async function registerNewCommand(webConsoleFront) {
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     this.WebConsoleCommands.register("setFoo", (owner, value) => {
       owner.window.foo = value;
       return "ok";
     });
 
     ok(
       this.WebConsoleCommands.hasCommand("setFoo"),
       "The command should be registered"
     );
   });
 
   const command = "setFoo('bar')";
-  await evaluateJSAndCheckResult(consoleClient, command, {
-    from: consoleClient.actor,
+  await evaluateJSAndCheckResult(webConsoleFront, command, {
+    from: webConsoleFront.actor,
     input: command,
     result: "ok",
   });
 
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     is(content.top.foo, "bar", "top.foo should equal to 'bar'");
   });
 }
 
-async function wrapCommand(consoleClient) {
+async function wrapCommand(webConsoleFront) {
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     const origKeys = this.WebConsoleCommands.getCommand("keys");
 
     const newKeys = (...args) => {
       const [, arg0] = args;
       if (arg0 === ">o_/") {
         return "bang!";
       }
@@ -78,23 +78,23 @@ async function wrapCommand(consoleClient
       this.WebConsoleCommands.getCommand("keys"),
       newKeys,
       "the keys() command should have been replaced"
     );
 
     this.origKeys = origKeys;
   });
 
-  await evaluateJSAndCheckResult(consoleClient, "keys('>o_/')", {
-    from: consoleClient.actor,
+  await evaluateJSAndCheckResult(webConsoleFront, "keys('>o_/')", {
+    from: webConsoleFront.actor,
     result: "bang!",
   });
 
-  await evaluateJSAndCheckResult(consoleClient, "keys({foo: 'bar'})", {
-    from: consoleClient.actor,
+  await evaluateJSAndCheckResult(webConsoleFront, "keys({foo: 'bar'})", {
+    from: webConsoleFront.actor,
     result: {
       class: "Array",
       preview: {
         items: ["foo"],
       },
     },
   });
 
@@ -104,44 +104,44 @@ async function wrapCommand(consoleClient
       this.WebConsoleCommands.getCommand("keys"),
       this.origKeys,
       "the keys() command should be restored"
     );
     delete this.origKeys;
   });
 }
 
-async function unregisterCommand(consoleClient) {
+async function unregisterCommand(webConsoleFront) {
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     this.WebConsoleCommands.unregister("setFoo");
   });
 
-  await evaluateJSAndCheckResult(consoleClient, "setFoo", {
-    from: consoleClient.actor,
+  await evaluateJSAndCheckResult(webConsoleFront, "setFoo", {
+    from: webConsoleFront.actor,
     input: "setFoo",
     result: {
       type: "undefined",
     },
     exceptionMessage: /setFoo is not defined/,
   });
 }
 
-async function registerAccessor(consoleClient) {
+async function registerAccessor(webConsoleFront) {
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     this.WebConsoleCommands.register("$foo", {
       get(owner) {
         const foo = owner.window.document.getElementById("quack");
         return owner.makeDebuggeeValue(foo);
       },
     });
   });
 
   const command = "$foo.textContent = '>o_/'";
-  await evaluateJSAndCheckResult(consoleClient, command, {
-    from: consoleClient.actor,
+  await evaluateJSAndCheckResult(webConsoleFront, command, {
+    from: webConsoleFront.actor,
     input: command,
     result: ">o_/",
   });
 
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     is(
       content.document.getElementById("quack").textContent,
       ">o_/",
@@ -150,51 +150,51 @@ async function registerAccessor(consoleC
     this.WebConsoleCommands.unregister("$foo");
     ok(
       !this.WebConsoleCommands.hasCommand("$foo"),
       "$foo should be unregistered"
     );
   });
 }
 
-async function unregisterAfterOverridingTwice(consoleClient) {
+async function unregisterAfterOverridingTwice(webConsoleFront) {
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     this.WebConsoleCommands.register("keys", (owner, obj) => "command 1");
   });
 
   info("checking the value of the first override");
-  await evaluateJSAndCheckResult(consoleClient, "keys('foo');", {
+  await evaluateJSAndCheckResult(webConsoleFront, "keys('foo');", {
     result: "command 1",
   });
 
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     const orig = this.WebConsoleCommands.getCommand("keys");
     this.WebConsoleCommands.register("keys", (owner, obj) => {
       if (obj === "quack") {
         return "bang!";
       }
       return orig(owner, obj);
     });
   });
 
   info("checking the values after the second override");
-  await evaluateJSAndCheckResult(consoleClient, "keys({});", {
+  await evaluateJSAndCheckResult(webConsoleFront, "keys({});", {
     result: "command 1",
   });
-  await evaluateJSAndCheckResult(consoleClient, "keys('quack');", {
+  await evaluateJSAndCheckResult(webConsoleFront, "keys('quack');", {
     result: "bang!",
   });
 
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     this.WebConsoleCommands.unregister("keys");
   });
 
   info(
     "checking the value after unregistration (should restore " +
       "the original command)"
   );
-  await evaluateJSAndCheckResult(consoleClient, "keys({});", {
+  await evaluateJSAndCheckResult(webConsoleFront, "keys({});", {
     result: {
       class: "Array",
       preview: { items: [] },
     },
   });
 }
--- a/devtools/shared/webconsole/test/browser/browser_network_longstring.js
+++ b/devtools/shared/webconsole/test/browser/browser_network_longstring.js
@@ -10,34 +10,34 @@ const LONG_STRING_LENGTH = 400;
 const LONG_STRING_INITIAL_LENGTH = 400;
 let ORIGINAL_LONG_STRING_LENGTH, ORIGINAL_LONG_STRING_INITIAL_LENGTH;
 
 add_task(async function() {
   const tab = await addTab(URL_ROOT + "network_requests_iframe.html");
 
   const target = await getTargetForTab(tab);
   const { client } = target;
-  const consoleClient = target.activeConsole;
+  const webConsoleFront = target.activeConsole;
 
-  await consoleClient.startListeners(["NetworkActivity"]);
+  await webConsoleFront.startListeners(["NetworkActivity"]);
 
   // Override the default long string settings to lower values.
   // This is done from the parent process's DebuggerServer as the LongString
   // actor is being created from the parent process as network requests are
   // watched from the parent process.
   ORIGINAL_LONG_STRING_LENGTH = DebuggerServer.LONG_STRING_LENGTH;
   ORIGINAL_LONG_STRING_INITIAL_LENGTH =
     DebuggerServer.LONG_STRING_INITIAL_LENGTH;
 
   DebuggerServer.LONG_STRING_LENGTH = LONG_STRING_LENGTH;
   DebuggerServer.LONG_STRING_INITIAL_LENGTH = LONG_STRING_INITIAL_LENGTH;
 
   info("test network POST request");
 
-  const onNetworkEvent = consoleClient.once("serverNetworkEvent");
+  const onNetworkEvent = webConsoleFront.once("serverNetworkEvent");
   const updates = [];
   let netActor = null;
   const onAllNetworkEventUpdateReceived = new Promise(resolve => {
     const onNetworkEventUpdate = packet => {
       updates.push(packet.updateType);
       assertNetworkEventUpdate(netActor, packet);
 
       if (
@@ -52,42 +52,42 @@ add_task(async function() {
   });
 
   await ContentTask.spawn(gBrowser.selectedBrowser, null, async function() {
     content.wrappedJSObject.testXhrPost();
   });
 
   info("Waiting for networkEvent");
   const netEvent = await onNetworkEvent;
-  netActor = assertNetworkEvent(client, consoleClient, netEvent);
+  netActor = assertNetworkEvent(client, webConsoleFront, netEvent);
 
   info("Waiting for all networkEventUpdate");
   await onAllNetworkEventUpdateReceived;
-  const requestHeaders = await consoleClient.getRequestHeaders(netActor);
+  const requestHeaders = await webConsoleFront.getRequestHeaders(netActor);
   assertRequestHeaders(requestHeaders);
-  const requestCookies = await consoleClient.getRequestCookies(netActor);
+  const requestCookies = await webConsoleFront.getRequestCookies(netActor);
   assertRequestCookies(requestCookies);
-  const requestPostData = await consoleClient.getRequestPostData(netActor);
+  const requestPostData = await webConsoleFront.getRequestPostData(netActor);
   assertRequestPostData(requestPostData);
-  const responseHeaders = await consoleClient.getResponseHeaders(netActor);
+  const responseHeaders = await webConsoleFront.getResponseHeaders(netActor);
   assertResponseHeaders(responseHeaders);
-  const responseCookies = await consoleClient.getResponseCookies(netActor);
+  const responseCookies = await webConsoleFront.getResponseCookies(netActor);
   assertResponseCookies(responseCookies);
-  const responseContent = await consoleClient.getResponseContent(netActor);
+  const responseContent = await webConsoleFront.getResponseContent(netActor);
   assertResponseContent(responseContent);
-  const eventTimings = await consoleClient.getEventTimings(netActor);
+  const eventTimings = await webConsoleFront.getEventTimings(netActor);
   assertEventTimings(eventTimings);
 
   await target.destroy();
 
   DebuggerServer.LONG_STRING_LENGTH = ORIGINAL_LONG_STRING_LENGTH;
   DebuggerServer.LONG_STRING_INITIAL_LENGTH = ORIGINAL_LONG_STRING_INITIAL_LENGTH;
 });
 
-function assertNetworkEvent(client, consoleClient, packet) {
+function assertNetworkEvent(client, webConsoleFront, packet) {
   info("checking the network event packet");
 
   const netActor = packet.eventActor;
 
   checkObject(netActor, {
     actor: /[a-z]/,
     startedDateTime: /^\d+\-\d+\-\d+T.+$/,
     url: /data\.json/,
--- a/devtools/shared/webconsole/test/common.js
+++ b/devtools/shared/webconsole/test/common.js
@@ -83,26 +83,26 @@ var _attachConsole = async function(list
       }
     }
 
     // Attach the Target and the target thread in order to instantiate the console client.
     await target.attach();
     const [, threadFront] = await target.attachThread();
     await threadFront.resume();
 
-    const webConsoleClient = target.activeConsole;
+    const webConsoleFront = target.activeConsole;
 
     // By default the console isn't listening for anything,
     // request listeners from here
-    const response = await webConsoleClient.startListeners(listeners);
+    const response = await webConsoleFront.startListeners(listeners);
     return {
       state: {
         dbgClient: client,
-        client: webConsoleClient,
-        actor: webConsoleClient.actor,
+        webConsoleFront,
+        actor: webConsoleFront.actor,
         // Keep a strong reference to the Worker to avoid it being
         // GCd during the test (bug 1237492).
         // eslint-disable-next-line camelcase
         _worker_ref: worker,
       },
       response,
     };
   } catch (error) {
--- a/devtools/shared/webconsole/test/test_basics.html
+++ b/devtools/shared/webconsole/test/test_basics.html
@@ -41,17 +41,17 @@ function onStartPageErrorAndConsoleAPI(a
   is(startedListeners.length, 2, "startedListeners.length");
   isnot(startedListeners.indexOf("PageError"), -1, "startedListeners: PageError");
   isnot(startedListeners.indexOf("ConsoleAPI"), -1,
         "startedListeners: ConsoleAPI");
   is(startedListeners.indexOf("foo"), -1, "startedListeners: no foo");
   ok(!aResponse.nativeConsoleAPI, "!nativeConsoleAPI");
 
   top.console = top.console_;
-  aState.client.stopListeners(["ConsoleAPI", "foo"])
+  aState.webConsoleFront.stopListeners(["ConsoleAPI", "foo"])
     .then(onStopConsoleAPI.bind(null, aState));
 }
 
 function onStopConsoleAPI(aState, aResponse)
 {
   is(aResponse.stoppedListeners.length, 1, "stoppedListeners.length");
   is(aResponse.stoppedListeners[0], "ConsoleAPI", "stoppedListeners: ConsoleAPI");
 
--- a/devtools/shared/webconsole/test/test_bug819670_getter_throws.html
+++ b/devtools/shared/webconsole/test/test_bug819670_getter_throws.html
@@ -18,17 +18,17 @@ function startTest()
 {
   removeEventListener("load", startTest);
   attachConsoleToTab([], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onEvaluate = onEvaluate.bind(null, aState);
-  aState.client.evaluateJS("document.__proto__").then(onEvaluate);
+  aState.webConsoleFront.evaluateJS("document.__proto__").then(onEvaluate);
 }
 
 function onEvaluate(aState, aResponse)
 {
   checkObject(aResponse, {
     from: aState.actor,
     input: "document.__proto__",
     result: {
--- a/devtools/shared/webconsole/test/test_cached_messages.html
+++ b/devtools/shared/webconsole/test/test_cached_messages.html
@@ -148,17 +148,17 @@ function startTest() {
 
 function checkConsoleAPICache() {
   consoleAPIListener.destroy();
   consoleAPIListener = null;
   attachConsole(["ConsoleAPI"], onAttach1);
 }
 
 function onAttach1(state, response) {
-  state.client.getCachedMessages(["ConsoleAPI"])
+  state.webConsoleFront.getCachedMessages(["ConsoleAPI"])
     .then(onCachedConsoleAPI.bind(null, state));
 }
 
 function onCachedConsoleAPI(state, response) {
   let msgs = response.messages;
   info("cached console messages: " + msgs.length);
 
   ok(msgs.length >= expectedConsoleCalls.length,
@@ -186,17 +186,17 @@ function onCachedConsoleAPI(state, respo
 
 function testPageErrors() {
   consoleServiceListener.destroy();
   consoleServiceListener = null;
   attachConsole(["PageError"], onAttach2);
 }
 
 function onAttach2(state, response) {
-  state.client.getCachedMessages(["PageError"])
+  state.webConsoleFront.getCachedMessages(["PageError"])
     .then(onCachedPageErrors.bind(null, state));
 }
 
 function onCachedPageErrors(state, response) {
   let msgs = response.messages;
   info("cached page errors: " + msgs.length);
 
   ok(msgs.length >= expectedPageErrors.length,
--- a/devtools/shared/webconsole/test/test_commands_other.html
+++ b/devtools/shared/webconsole/test/test_commands_other.html
@@ -13,17 +13,17 @@
 
 <script class="testbody" type="text/javascript">
 SimpleTest.waitForExplicitFinish();
 let gState;
 let gWin;
 let tests;
 
 function evaluateJS(input) {
-  return gState.client.evaluateJS(input);
+  return gState.webConsoleFront.evaluateJS(input);
 }
 
 function startTest() {
   info ("Content window opened, attaching console to it");
 
   let systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
   ok (!gWin.document.nodePrincipal.equals(systemPrincipal),
       "The test document is not using the system principal");
--- a/devtools/shared/webconsole/test/test_console_assert.html
+++ b/devtools/shared/webconsole/test/test_console_assert.html
@@ -12,23 +12,23 @@
 
 window.onload = async function () {
   SimpleTest.waitForExplicitFinish();
   let state;
   try {
     state = await new Promise(resolve =>
       attachConsole(["ConsoleAPI"], resolve)
     );
-    const {client} = state;
+    const {webConsoleFront} = state;
 
-    await testFalseAssert(client);
-    await testFalsyAssert(client);
-    await testUndefinedAssert(client);
-    await testNullAssert(client);
-    await testTrueAssert(client);
+    await testFalseAssert(webConsoleFront);
+    await testFalsyAssert(webConsoleFront);
+    await testUndefinedAssert(webConsoleFront);
+    await testNullAssert(webConsoleFront);
+    await testTrueAssert(webConsoleFront);
 
   } catch (e) {
     ok(false, `Error thrown: ${e.message}`);
   }
 
   await closeDebugger(state);
   SimpleTest.finish();
 };
--- a/devtools/shared/webconsole/test/test_console_group_styling.html
+++ b/devtools/shared/webconsole/test/test_console_group_styling.html
@@ -16,17 +16,17 @@ window.onload = async function () {
   SimpleTest.waitForExplicitFinish();
   let state;
   try {
     const onAttachConsole = new Promise(resolve => attachConsole(
       ["ConsoleAPI"],
       (consoleState, response) => resolve(consoleState)
     ));
     state = await onAttachConsole;
-    const consoleFront = state.client;
+    const consoleFront = state.webConsoleFront;
 
     await testSingleCustomStyleGroup(consoleFront);
     await testSingleCustomStyleGroupCollapsed(consoleFront);
     await testMultipleCustomStyleGroup(consoleFront);
     await testMultipleCustomStyleGroupCollapsed(consoleFront);
     await testFormatterWithNoStyleGroup(consoleFront);
     await testFormatterWithNoStyleGroupCollapsed(consoleFront);
   } catch (e) {
--- a/devtools/shared/webconsole/test/test_console_serviceworker.html
+++ b/devtools/shared/webconsole/test/test_console_serviceworker.html
@@ -111,17 +111,17 @@ let startTest = async function () {
   });
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 };
 addEventListener("load", startTest);
 
 let onAttach = async function (state, response) {
   onConsoleAPICall = onConsoleAPICall.bind(null, state);
-  state.client.on("consoleAPICall", onConsoleAPICall);
+  state.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
 
   let currentFrame;
   try {
     // First, we need a frame from which to register our script.  This
     // will not trigger any console calls.
     info("Loading a non-scope frame from which to register a service worker.");
     currentFrame = await withFrame(NONSCOPE_FRAME_URL);
 
@@ -169,17 +169,17 @@ let onAttach = async function (state, re
     // have a controlled or registering document.
     info("Completed force refresh.  Messaging service worker.");
     await messageServiceWorker(currentFrame.contentWindow, SCOPE, MESSAGE);
 
     info("Done messaging service worker.  Unregistering service worker.");
     await unregisterServiceWorker(currentFrame.contentWindow);
 
     info('Service worker unregistered.  Checking console calls.');
-    state.client.off("consoleAPICall", onConsoleAPICall);
+    state.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
     checkConsoleAPICalls(consoleCalls, expectedConsoleCalls);
   } catch(error) {
     ok(false, 'unexpected error: ' + error);
   } finally {
     if (currentFrame) {
       currentFrame.remove();
       currentFrame = null;
     }
--- a/devtools/shared/webconsole/test/test_console_serviceworker_cached.html
+++ b/devtools/shared/webconsole/test/test_console_serviceworker_cached.html
@@ -57,32 +57,32 @@ let startTest = async function () {
   info("Adding a tab and attaching a service worker");
   let tab1 = await addTab(FRAME_URL);
   let swr = await withActiveServiceWorker(tab1.linkedBrowser.contentWindow,
                                 SERVICE_WORKER_URL);
 
   await new Promise(resolve => {
     info("Attaching console to tab 1");
     attachConsoleToTab(["ConsoleAPI"], function(state) {
-      state.client.getCachedMessages(["ConsoleAPI"]).then(function(calls) {
+      state.webConsoleFront.getCachedMessages(["ConsoleAPI"]).then(function(calls) {
         checkConsoleAPICalls(calls.messages, firstTabExpectedCalls);
         closeDebugger(state, resolve);
       });
     });
   });
 
   // Because this tab is being added after the original messages happened,
   // they shouldn't show up in a call to getCachedMessages.
   // However, there is a fetch event which is logged due to loading the tab.
   info("Adding a new tab at the same URL");
   let tab2 = await addTab(FRAME_URL);
   await new Promise(resolve => {
     info("Attaching console to tab 2");
     attachConsoleToTab(["ConsoleAPI"], function(state) {
-      state.client.getCachedMessages(["ConsoleAPI"]).then(function(calls) {
+      state.webConsoleFront.getCachedMessages(["ConsoleAPI"]).then(function(calls) {
         checkConsoleAPICalls(calls.messages, secondTabExpectedCalls);
         closeDebugger(state, resolve);
       });
     });
   });
 
   await swr.unregister();
 
--- a/devtools/shared/webconsole/test/test_console_styling.html
+++ b/devtools/shared/webconsole/test/test_console_styling.html
@@ -84,32 +84,32 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onConsoleAPICall = onConsoleAPICall.bind(null, aState);
-  aState.client.on("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
   doConsoleCalls(aState.actor);
 }
 
 let consoleCalls = [];
 
 function onConsoleAPICall(aState, aPacket)
 {
   info("received message level: " + aPacket.message.level);
 
   consoleCalls.push(aPacket.message);
   if (consoleCalls.length != expectedConsoleCalls.length) {
     return;
   }
 
-  aState.client.off("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
 
   expectedConsoleCalls.forEach(function(aMessage, aIndex) {
     info("checking received console call #" + aIndex);
     checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
   });
 
 
   consoleCalls = [];
--- a/devtools/shared/webconsole/test/test_console_timestamp.html
+++ b/devtools/shared/webconsole/test/test_console_timestamp.html
@@ -16,17 +16,17 @@ window.onload = async function () {
   SimpleTest.waitForExplicitFinish();
   let state;
   try {
     const onAttachConsole = new Promise(resolve => attachConsole(
       ["ConsoleAPI"],
       (consoleState, response) => resolve(consoleState)
     ));
     state = await onAttachConsole;
-    const consoleFront = state.client;
+    const consoleFront = state.webConsoleFront;
 
     info("Testing console.log packet timestamp correctness");
     const clientLogTimestamp = Date.now();
     const packet = await consoleAPICall(consoleFront,
       () => top.console.log("test"));
     const packetReceivedTimestamp = Date.now();
 
     const {timeStamp} = packet.message;
--- a/devtools/shared/webconsole/test/test_console_worker.html
+++ b/devtools/shared/webconsole/test/test_console_worker.html
@@ -49,33 +49,33 @@ let testCachedMessages = async function 
   return new Promise(resolve => {
     let onCachedConsoleAPI = (response) => {
       let consoleCalls = response.messages;
 
       info('Received cached response. Checking console calls.');
       checkConsoleAPICalls(consoleCalls, expectedCachedConsoleCalls);
       resolve();
     };
-    state.client.getCachedMessages(["ConsoleAPI"]).then(onCachedConsoleAPI);
+    state.webConsoleFront.getCachedMessages(["ConsoleAPI"]).then(onCachedConsoleAPI);
   })
 };
 
 let testConsoleAPI = async function (state) {
   info("testConsoleAPI entered");
   return new Promise(resolve => {
     let onConsoleAPICall = (packet) => {
       info("received message level: " + packet.message.level);
       checkConsoleAPICalls([packet.message], expectedConsoleAPICalls);
-      state.client.off("consoleAPICall", onConsoleAPICall);
+      state.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
       resolve();
     }
 
     info("testConsoleAPI: adding listener for consoleAPICall");
-    state.client.on("consoleAPICall", onConsoleAPICall);
+    state.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
 
-    state.client.evaluateJS("console.log('Log was requested from worker')",
+    state.webConsoleFront.evaluateJS("console.log('Log was requested from worker')",
       () => { });
   });
 };
 
 </script>
 </body>
 </html>
--- a/devtools/shared/webconsole/test/test_consoleapi.html
+++ b/devtools/shared/webconsole/test/test_consoleapi.html
@@ -191,32 +191,32 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onConsoleAPICall = onConsoleAPICall.bind(null, aState);
-  aState.client.on("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
   doConsoleCalls(aState.actor);
 }
 
 let consoleCalls = [];
 
 function onConsoleAPICall(aState, aPacket)
 {
   info("received message level: " + aPacket.message.level);
 
   consoleCalls.push(aPacket.message);
   if (consoleCalls.length != expectedConsoleCalls.length) {
     return;
   }
 
-  aState.client.off("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
 
   expectedConsoleCalls.forEach(function(aMessage, aIndex) {
     info("checking received console call #" + aIndex);
     checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
   });
 
 
   consoleCalls = [];
--- a/devtools/shared/webconsole/test/test_consoleapi_innerID.html
+++ b/devtools/shared/webconsole/test/test_consoleapi_innerID.html
@@ -120,32 +120,32 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onConsoleAPICall = onConsoleAPICall.bind(null, aState);
-  aState.client.on("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
   doConsoleCalls(aState.actor);
 }
 
 let consoleCalls = [];
 
 function onConsoleAPICall(aState, aPacket)
 {
   info("received message level: " + aPacket.message.level);
 
   consoleCalls.push(aPacket.message);
   if (consoleCalls.length != expectedConsoleCalls.length) {
     return;
   }
 
-  aState.client.off("consoleAPICall", onConsoleAPICall);
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
 
   expectedConsoleCalls.forEach(function(aMessage, aIndex) {
     info("checking received console call #" + aIndex);
     checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
   });
 
 
   consoleCalls = [];
--- a/devtools/shared/webconsole/test/test_file_uri.html
+++ b/devtools/shared/webconsole/test/test_file_uri.html
@@ -54,23 +54,23 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsole(["FileActivity"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   gState = aState;
-  gState.client.on("fileActivity", onFileActivity);
+  gState.webConsoleFront.on("fileActivity", onFileActivity);
   doFileActivity();
 }
 
 function onFileActivity(aPacket)
 {
-  gState.client.off("fileActivity", onFileActivity);
+  gState.webConsoleFront.off("fileActivity", onFileActivity);
 
   info("aPacket.uri: " + aPacket.uri);
   ok(/\bbug798764\b.*\.html$/.test(aPacket.uri), "file URI match");
 
   testEnd();
 }
 
 function testEnd()
--- a/devtools/shared/webconsole/test/test_jsterm.html
+++ b/devtools/shared/webconsole/test/test_jsterm.html
@@ -20,19 +20,19 @@ let gState;
 
 let {MAX_AUTOCOMPLETE_ATTEMPTS,MAX_AUTOCOMPLETIONS} = require("devtools/shared/webconsole/js-property-provider");
 
 // This test runs all of its assertions twice - once with
 // evaluateJS and once with evaluateJSAsync.
 let evaluatingSync = true;
 function evaluateJS(input, options = {}) {
   if (evaluatingSync) {
-    return gState.client.evaluateJS(input, options);
+    return gState.webConsoleFront.evaluateJS(input, options);
   } else {
-    return gState.client.evaluateJSAsync(input, options);
+    return gState.webConsoleFront.evaluateJSAsync(input, options);
   }
 }
 
 function startTest()
 {
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["PageError"], onAttach);
--- a/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
+++ b/devtools/shared/webconsole/test/test_jsterm_autocomplete.html
@@ -85,17 +85,17 @@
         "data-test": "",
         'da"ta"test': "",
         'da\`ta\`test': "",
         "da'ta'test": "",
       }));
 
       window.varify = true;
     `;
-    await state.client.evaluateJSAsync(script);
+    await state.webConsoleFront.evaluateJSAsync(script);
 
     const tests = [
       doAutocomplete1,
       doAutocomplete2,
       doAutocomplete3,
       doAutocomplete4,
       doAutocompleteLarge1,
       doAutocompleteLarge2,
@@ -120,372 +120,372 @@
         doAutocompleteArray,
         doAutocompleteString,
         doAutocompleteCommands,
         doAutocompleteBracketSurroundedBySpaces,
       );
     }
 
     for (const test of tests) {
-      await test(state.client);
+      await test(state.webConsoleFront);
     }
 
     // Null out proxy1 and proxy2: the proxy handlers use scripted functions
     // that can keep the debugger sandbox alive longer than necessary via their
     // environment chain (due to the webconsole helper functions defined there).
-    await state.client.evaluateJSAsync(`this.proxy1 = null; this.proxy2 = null;`);
+    await state.webConsoleFront.evaluateJSAsync(`this.proxy1 = null; this.proxy2 = null;`);
 
     await closeDebugger(state);
   }
 
-  async function doAutocomplete1(client) {
+  async function doAutocomplete1(webConsoleFront) {
     info("test autocomplete for 'window.foo'");
-    let response = await client.autocomplete("window.foo");
+    let response = await webConsoleFront.autocomplete("window.foo");
     let matches = response.matches;
 
     is(response.matchProp, "foo", "matchProp");
     is(matches.length, 1, "matches.length");
     is(matches[0], "foobarObject", "matches[0]");
   }
 
-  async function doAutocomplete2(client) {
+  async function doAutocomplete2(webConsoleFront) {
     info("test autocomplete for 'window.foobarObject.'");
-    let response = await client.autocomplete("window.foobarObject.");
+    let response = await webConsoleFront.autocomplete("window.foobarObject.");
     let matches = response.matches;
 
     ok(!response.matchProp, "matchProp");
     is(matches.length, 7, "matches.length");
     checkObject(matches,
       ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
   }
 
-  async function doAutocomplete3(client) {
+  async function doAutocomplete3(webConsoleFront) {
     // Check that completion suggestions are offered inside the string.
     info("test autocomplete for 'dump(window.foobarObject.)'");
-    let response = await client.autocomplete("dump(window.foobarObject.)", 25);
+    let response = await webConsoleFront.autocomplete("dump(window.foobarObject.)", 25);
     let matches = response.matches;
 
     ok(!response.matchProp, "matchProp");
     is(matches.length, 7, "matches.length");
     checkObject(matches,
       ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
   }
 
-  async function doAutocomplete4(client) {
+  async function doAutocomplete4(webConsoleFront) {
     // Check that completion requests can have no suggestions.
     info("test autocomplete for 'dump(window.foobarObject.)'");
-    let response = await client.autocomplete("dump(window.foobarObject.)");
+    let response = await webConsoleFront.autocomplete("dump(window.foobarObject.)");
     ok(!response.matchProp, "matchProp");
     is(response.matches, null, "matches is null");
   }
 
-  async function doAutocompleteLarge1(client) {
+  async function doAutocompleteLarge1(webConsoleFront) {
     // Check that completion requests with too large objects will
     // have no suggestions.
     info("test autocomplete for 'window.largeObject1.'");
-    let response = await client.autocomplete("window.largeObject1.");
+    let response = await webConsoleFront.autocomplete("window.largeObject1.");
     ok(!response.matchProp, "matchProp");
     info (response.matches.join("|"));
     is(response.matches.length, 0, "Bailed out with too many properties");
   }
 
-  async function doAutocompleteLarge2(client) {
+  async function doAutocompleteLarge2(webConsoleFront) {
     // Check that completion requests with pretty large objects will
     // have MAX_AUTOCOMPLETIONS suggestions
     info("test autocomplete for 'window.largeObject2.'");
-    let response = await client.autocomplete("window.largeObject2.");
+    let response = await webConsoleFront.autocomplete("window.largeObject2.");
     ok(!response.matchProp, "matchProp");
     is(response.matches.length, MAX_AUTOCOMPLETIONS, "matches.length is MAX_AUTOCOMPLETIONS");
   }
 
-  async function doAutocompleteProxyThrowsPrototype(client) {
+  async function doAutocompleteProxyThrowsPrototype(webConsoleFront) {
     // Check that completion provides own properties even if [[GetPrototypeOf]] throws.
     info("test autocomplete for 'window.proxy1.'");
-    let response = await client.autocomplete("window.proxy1.");
+    let response = await webConsoleFront.autocomplete("window.proxy1.");
     ok(!response.matchProp, "matchProp");
     is(response.matches.length, 1, "matches.length");
     checkObject(response.matches, ["foo"]);
   }
 
-  async function doAutocompleteProxyThrowsOwnKeys(client) {
+  async function doAutocompleteProxyThrowsOwnKeys(webConsoleFront) {
     // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws.
     info("test autocomplete for 'window.proxy2.'");
-    let response = await client.autocomplete("window.proxy2.");
+    let response = await webConsoleFront.autocomplete("window.proxy2.");
     ok(!response.matchProp, "matchProp");
     is(response.matches.length, 1, "matches.length");
     checkObject(response.matches, ["foo"]);
   }
 
-  async function doAutocompleteSandbox(client) {
+  async function doAutocompleteSandbox(webConsoleFront) {
     // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws.
     info("test autocomplete for 'Cu.Sandbox.'");
-    let response = await client.autocomplete("Cu.Sandbox.");
+    let response = await webConsoleFront.autocomplete("Cu.Sandbox.");
     ok(!response.matchProp, "matchProp");
     let keys = Object.getOwnPropertyNames(Object.prototype).sort();
     is(response.matches.length, keys.length, "matches.length");
     // checkObject(response.matches, keys);
     is(response.matches.join(" - "), keys.join(" - "));
   }
 
-  async function doAutocompleteArray(client) {
+  async function doAutocompleteArray(webConsoleFront) {
     info("test autocomplete for [1,2,3]");
-    let response = await client.autocomplete("[1,2,3].");
+    let response = await webConsoleFront.autocomplete("[1,2,3].");
     let {matches} = response;
 
     ok(matches.length > 0, "There are completion results for the array");
     ok(matches.includes("length") && matches.includes("filter"),
       "Array autocomplete contains expected results");
 
     info("test autocomplete for '[] . '");
-    matches = (await client.autocomplete("[] . ")).matches;
+    matches = (await webConsoleFront.autocomplete("[] . ")).matches;
     ok(matches.length > 1);
     ok(matches.includes("length") && matches.includes("filter"),
       "Array autocomplete contains expected results");
     ok(!matches.includes("copy"), "Array autocomplete does not contain helpers");
 
     info("test autocomplete for '[1,2,3]['");
-    matches = (await client.autocomplete("[1,2,3][")).matches;
+    matches = (await webConsoleFront.autocomplete("[1,2,3][")).matches;
     ok(matches.length > 1);
     ok(matches.includes('"length"') && matches.includes('"filter"'),
       "Array autocomplete contains expected results, surrounded by quotes");
 
     info("test autocomplete for '[1,2,3]['");
-    matches = (await client.autocomplete("[1,2,3]['")).matches;
+    matches = (await webConsoleFront.autocomplete("[1,2,3]['")).matches;
     ok(matches.length > 1);
     ok(matches.includes("'length'") && matches.includes("'filter'"),
       "Array autocomplete contains expected results, surrounded by quotes");
 
     info("test autocomplete for '[1,2,3][l");
-    matches = (await client.autocomplete("[1,2,3][l")).matches;
+    matches = (await webConsoleFront.autocomplete("[1,2,3][l")).matches;
     ok(matches.length >= 1);
     ok(matches.includes('"length"'),
       "Array autocomplete contains expected results, surrounded by quotes");
 
     info("test autocomplete for '[1,2,3]['l");
-    matches = (await client.autocomplete("[1,2,3]['l")).matches;
+    matches = (await webConsoleFront.autocomplete("[1,2,3]['l")).matches;
     ok(matches.length >= 1);
     ok(matches.includes("'length'"),
       "Array autocomplete contains expected results, surrounded by quotes");
   }
 
-  async function doAutocompleteString(client) {
+  async function doAutocompleteString(webConsoleFront) {
     info(`test autocomplete for "foo".`);
-    let response = await client.autocomplete(`"foo".`);
+    let response = await webConsoleFront.autocomplete(`"foo".`);
     let {matches} = response;
 
     ok(matches.length > 0, "There are completion results for the string");
     ok(matches.includes("substr") && matches.includes("trim"),
       "String autocomplete contains expected results");
 
     info("test autocomplete for `foo`[");
-    matches = (await client.autocomplete("`foo`[")).matches;
+    matches = (await webConsoleFront.autocomplete("`foo`[")).matches;
     ok(matches.length > 1, "autocomplete string with bracket works");
     ok(matches.includes('"substr"') && matches.includes('"trim"'),
       "String autocomplete contains expected results, surrounded by quotes");
   }
 
-  async function doAutocompleteDotSurroundedBySpaces(client) {
+  async function doAutocompleteDotSurroundedBySpaces(webConsoleFront) {
     info("test autocomplete for 'window.foobarObject\n  .'");
-    let {matches} = await client.autocomplete("window.foobarObject\n  .");
+    let {matches} = await webConsoleFront.autocomplete("window.foobarObject\n  .");
     is(matches.length, 7);
     checkObject(matches,
       ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
 
     info("test autocomplete for 'window.foobarObject\n  .o'");
-    matches = (await client.autocomplete("window.foobarObject\n  .o")).matches;
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .o")).matches;
     is(matches.length, 3);
     checkObject(matches, ["omg", "omgfoo", "omgstr"]);
 
     info("test autocomplete for 'window.foobarObject\n  .\n  s'");
-    matches = (await client.autocomplete("window.foobarObject\n  .\n  s")).matches;
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .\n  s")).matches;
     is(matches.length, 1);
     checkObject(matches, ["strfoo"]);
 
     info("test autocomplete for 'window.foobarObject\n  .  '");
-    matches = (await client.autocomplete("window.foobarObject\n  .  ")).matches;
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .  ")).matches;
     is(matches.length, 7);
     checkObject(matches,
       ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
 
     matches =
-      (await client.autocomplete("window.foobarObject.  foo ; window.foo")).matches;
+      (await webConsoleFront.autocomplete("window.foobarObject.  foo ; window.foo")).matches;
     is(matches.length, 1);
     checkObject(matches, ["foobarObject"]);
   }
 
-  async function doAutocompleteBracketSurroundedBySpaces(client) {
+  async function doAutocompleteBracketSurroundedBySpaces(webConsoleFront) {
     const wrap = (arr, quote = `"`) => arr.map(x => `${quote}${x}${quote}`);
-    let matches = await getAutocompleteMatches(client, "window.foobarObject\n  [")
+    let matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [")
     is(matches.length, 7);
     checkObject(matches,
       wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]));
 
-    matches = await getAutocompleteMatches(client, "window.foobarObject\n  ['o")
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  ['o")
     is(matches.length, 3);
     checkObject(matches, wrap(["omg", "omgfoo", "omgstr"], "'"));
 
-    matches = await getAutocompleteMatches(client, "window.foobarObject\n  [\n  s");
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [\n  s");
     is(matches.length, 1);
     checkObject(matches, [`"strfoo"`]);
 
-    matches = await getAutocompleteMatches(client, "window.foobarObject\n  [  ");
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [  ");
     is(matches.length, 7);
     checkObject(matches,
       wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]));
 
-    matches = await getAutocompleteMatches(client, "window.emojiObject  [   '");
+    matches = await getAutocompleteMatches(webConsoleFront, "window.emojiObject  [   '");
     is(matches.length, 1);
     checkObject(matches, [`'😎'`]);
   }
 
-  async function doAutocompleteAfterOr(client) {
+  async function doAutocompleteAfterOr(webConsoleFront) {
     info("test autocomplete for 'true || foo'");
-    const {matches} = await client.autocomplete("true || foobar");
+    const {matches} = await webConsoleFront.autocomplete("true || foobar");
     is(matches.length, 1, "autocomplete returns expected results");
     is(matches.join("-"), "foobarObject");
   }
 
-  async function doInsensitiveAutocomplete(client) {
+  async function doInsensitiveAutocomplete(webConsoleFront) {
     info("test autocomplete for 'window.insensitiveTestCase.'");
-    let {matches} = await client.autocomplete("window.insensitiveTestCase.");
+    let {matches} = await webConsoleFront.autocomplete("window.insensitiveTestCase.");
     is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP",
       "autocomplete returns the expected items, in the expected order");
 
     info("test autocomplete for 'window.insensitiveTestCase.p'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.p")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.p")).matches;
     is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP",
       "autocomplete is case-insensitive when first letter is lowercased");
 
     info("test autocomplete for 'window.insensitiveTestCase.pRoP'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.pRoP")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.pRoP")).matches;
     is(matches.join("-"), "prop-Prop-PROP",
       "autocomplete is case-insensitive when first letter is lowercased");
 
     info("test autocomplete for 'window.insensitiveTestCase.P'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.P")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.P")).matches;
     is(matches.join("-"), "Prop-PROP-PRÖP",
       "autocomplete is case-sensitive when first letter is uppercased");
 
     info("test autocomplete for 'window.insensitiveTestCase.PROP'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.PROP")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PROP")).matches;
     is(matches.join("-"), "PROP",
       "autocomplete is case-sensitive when first letter is uppercased");
 
     info("test autocomplete for 'window.insensitiveTestCase.prö'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.prö")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.prö")).matches;
     is(matches.join("-"), "pröp-PRÖP", "expected result with lowercase diacritic");
 
     info("test autocomplete for 'window.insensitiveTestCase.PRÖ'");
-    matches = (await client.autocomplete("window.insensitiveTestCase.PRÖ")).matches;
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PRÖ")).matches;
     is(matches.join("-"), "PRÖP", "expected result with uppercase diacritic");
   }
 
-  async function doElementAccessAutocomplete(client) {
+  async function doElementAccessAutocomplete(webConsoleFront) {
     info("test autocomplete for 'window.elementAccessTestCase['");
-    let res = (await client.autocomplete("window.elementAccessTestCase["));
+    let res = (await webConsoleFront.autocomplete("window.elementAccessTestCase["));
     is(
       res.matches.join("|"),
       `"bar"|"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"|"BAR"`,
       "autocomplete returns the expected items, wrapped in quotes");
     is(res.isElementAccess, true);
 
     info("test autocomplete for 'window.elementAccessTestCase[d'");
-    res = await client.autocomplete("window.elementAccessTestCase[d");
+    res = await webConsoleFront.autocomplete("window.elementAccessTestCase[d");
     is(
       res.matches.join("|"),
       `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`,
       "autocomplete returns the expected filtered items");
     is(res.isElementAccess, true);
 
     info(`test autocomplete for 'window.elementAccessTestCase["d'`);
-    res = await client.autocomplete(`window.elementAccessTestCase["d`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["d`);
     is(
       res.matches.join("|"),
       `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`,
       "autocomplete returns the expected items, wrapped in quotes");
     is(res.isElementAccess, true);
 
     info(`test autocomplete for 'window.elementAccessTestCase["data-`);
-    res = await client.autocomplete(`window.elementAccessTestCase["data-`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["data-`);
     is(res.matches.join("|"), `"data-test"`,
       "autocomplete returns the expected items, wrapped in quotes");
     is(res.isElementAccess, true);
 
     info(`test autocomplete for 'window.elementAccessTestCase['d'`);
-    res = await client.autocomplete(`window.elementAccessTestCase['d`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase['d`);
     is(
       res.matches.join("|"),
       `'da"ta"test'|'da\\'ta\\'test'|'da\`ta\`test'|'data-test'|'dataTest'`,
       "autocomplete returns the expected items, wrapped in the same quotes the user entered");
     is(res.isElementAccess, true);
 
     info("test autocomplete for 'window.elementAccessTestCase[`d'");
-    res = await client.autocomplete("window.elementAccessTestCase[`d");
+    res = await webConsoleFront.autocomplete("window.elementAccessTestCase[`d");
     is(
       res.matches.join("|"),
       "`da'ta'test`|`da\"ta\"test`|`da\\`ta\\`test`|`data-test`|`dataTest`",
       "autocomplete returns the expected items, wrapped in the same quotes the user entered");
     is(res.isElementAccess, true);
 
     info(`test autocomplete for '['`);
-    res = await client.autocomplete(`[`);
+    res = await webConsoleFront.autocomplete(`[`);
     is(res.matches, null, "it does not return anything");
 
     info(`test autocomplete for '[1,2,3'`);
-    res = await client.autocomplete(`[1,2,3`);
+    res = await webConsoleFront.autocomplete(`[1,2,3`);
     is(res.matches, null, "it does not return anything");
 
     info(`test autocomplete for '["'`);
-    res = await client.autocomplete(`["`);
+    res = await webConsoleFront.autocomplete(`["`);
     is(res.matches, null, "it does not return anything");
 
     info(`test autocomplete for '[;'`);
-    res = await client.autocomplete(`[;`);
+    res = await webConsoleFront.autocomplete(`[;`);
     is(res.matches, null, "it does not return anything");
   }
 
-  async function doAutocompleteCommands(client) {
+  async function doAutocompleteCommands(webConsoleFront) {
     info("test autocomplete for 'c'");
-    let matches = (await client.autocomplete("c")).matches;
+    let matches = (await webConsoleFront.autocomplete("c")).matches;
     ok(matches.includes("cd") && matches.includes("clear"), "commands are returned");
 
     info("test autocomplete for 's'");
-    matches = (await client.autocomplete("s")).matches;
+    matches = (await webConsoleFront.autocomplete("s")).matches;
     is(matches.includes("screenshot"), false, "screenshot is not returned");
 
     info("test autocomplete for ':s'");
-    matches = (await client.autocomplete(":s")).matches;
+    matches = (await webConsoleFront.autocomplete(":s")).matches;
     is(matches.includes(":screenshot"), true, "screenshot is returned");
 
     info("test autocomplete for 'window.c'");
-    matches = (await client.autocomplete("window.c")).matches;
+    matches = (await webConsoleFront.autocomplete("window.c")).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
 
     info("test autocomplete for 'window[c'");
-    matches = (await client.autocomplete("window[c")).matches;
+    matches = (await webConsoleFront.autocomplete("window[c")).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
 
     info(`test autocomplete for 'window["c'`);
-    matches = (await client.autocomplete(`window["c`)).matches;
+    matches = (await webConsoleFront.autocomplete(`window["c`)).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
 
     info(`test autocomplete for 'window["c'`);
-    matches = (await client.autocomplete(`window["c`)).matches;
+    matches = (await webConsoleFront.autocomplete(`window["c`)).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
 
     info(`test autocomplete for 'window[";c'`);
-    matches = (await client.autocomplete(`window[";c`)).matches;
+    matches = (await webConsoleFront.autocomplete(`window[";c`)).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
 
     info(`test autocomplete for 'window[;c'`);
-    matches = (await client.autocomplete(`window[;c`)).matches;
+    matches = (await webConsoleFront.autocomplete(`window[;c`)).matches;
     ok(!matches.includes("cd") && !matches.includes("clear"), "commands are not returned");
   }
 
-  async function doAutocompleteAfterOperator(client) {
+  async function doAutocompleteAfterOperator(webConsoleFront) {
     const inputs = [
       "true;foob",
       "true,foob",
       "({key:foob",
       "a=foob",
       "if(a<foob",
       "if(a>foob",
       "1+foob",
@@ -507,74 +507,74 @@
       "false&&foob",
       "x=true?foob",
       "x=false?1:foob",
       "!foob",
     ];
 
     for (const input of inputs) {
       info(`test autocomplete for "${input}"`);
-      let matches = (await client.autocomplete(input)).matches;
+      let matches = (await webConsoleFront.autocomplete(input)).matches;
       ok(matches.includes("foobarObject"), `Expected autocomplete result for ${input}"`);
     }
   }
 
-  async function dontAutocompleteAfterDeclaration(client) {
+  async function dontAutocompleteAfterDeclaration(webConsoleFront) {
     info("test autocomplete for 'var win'");
-    let matches = (await client.autocomplete("var win")).matches;
+    let matches = (await webConsoleFront.autocomplete("var win")).matches;
     is(matches, null, "no autocompletion on a var declaration");
 
     info("test autocomplete for 'const win'");
-    matches = (await client.autocomplete("const win")).matches;
+    matches = (await webConsoleFront.autocomplete("const win")).matches;
     is(matches, null, "no autocompletion on a const declaration");
 
     info("test autocomplete for 'let win'");
-    matches = (await client.autocomplete("let win")).matches;
+    matches = (await webConsoleFront.autocomplete("let win")).matches;
     is(matches, null, "no autocompletion on a let declaration");
 
     info("test autocomplete for 'function win'");
-    matches = (await client.autocomplete("function win")).matches;
+    matches = (await webConsoleFront.autocomplete("function win")).matches;
     is(matches, null, "no autocompletion on a function declaration");
 
     info("test autocomplete for 'class win'");
-    matches = (await client.autocomplete("class win")).matches;
+    matches = (await webConsoleFront.autocomplete("class win")).matches;
     is(matches, null, "no autocompletion on a class declaration");
 
     info("test autocomplete for 'const win = win'");
-    matches = (await client.autocomplete("const win = win")).matches;
+    matches = (await webConsoleFront.autocomplete("const win = win")).matches;
     ok(matches.includes("window"), "autocompletion still happens after the `=` sign");
 
     info("test autocomplete for 'in var'");
-    matches = (await client.autocomplete("in var")).matches;
+    matches = (await webConsoleFront.autocomplete("in var")).matches;
     ok(matches.includes("varify"),
       "autocompletion still happens with a property name starting with 'var'");
 }
 
-async function doKeywordsAutocomplete(client) {
+async function doKeywordsAutocomplete(webConsoleFront) {
   info("test autocomplete for 'func'");
-  let matches = (await client.autocomplete("func")).matches;
+  let matches = (await webConsoleFront.autocomplete("func")).matches;
   ok(matches.includes("function"), "keywords are returned");
 
   info("test autocomplete for ':func'");
-  matches = (await client.autocomplete(":func")).matches;
+  matches = (await webConsoleFront.autocomplete(":func")).matches;
   is(!matches.includes("function"), true,
     "'function' is not returned when prefixed with ':'");
 
   info("test autocomplete for 'window.func'");
-  matches = (await client.autocomplete("window.func")).matches;
+  matches = (await webConsoleFront.autocomplete("window.func")).matches;
   ok(!matches.includes("function"),
     "'function' is not returned when doing a property access");
 
   info("test autocomplete for 'window[func'");
-  matches = (await client.autocomplete("window[func")).matches;
+  matches = (await webConsoleFront.autocomplete("window[func")).matches;
   ok(!matches.includes("function"),
     "'function' is not returned when doing an element access");
   }
 
-  async function dontAutocomplete(client) {
+  async function dontAutocomplete(webConsoleFront) {
     const inputs = [
       "",
       "       ",
       "\n",
       "\n  ",
       "  \n  ",
       "  \n",
       "true;",
@@ -603,21 +603,21 @@ async function doKeywordsAutocomplete(cl
       "x=true?",
       "x=false?1:",
       "!",
       ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword} `),
       ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword}  `),
     ];
     for (const input of inputs) {
       info(`test autocomplete for "${input}"`);
-      let matches = (await client.autocomplete(input)).matches;
+      let matches = (await webConsoleFront.autocomplete(input)).matches;
       is(matches, null, `No autocomplete result for ${input}"`);
     }
   }
 
-  async function getAutocompleteMatches(client, input) {
+  async function getAutocompleteMatches(webConsoleFront, input) {
     info(`test autocomplete for "${input}"`);
-    const res = (await client.autocomplete(input));
+    const res = (await webConsoleFront.autocomplete(input));
     return res.matches;
   }
 </script>
 </body>
 </html>
--- a/devtools/shared/webconsole/test/test_jsterm_cd_iframe.html
+++ b/devtools/shared/webconsole/test/test_jsterm_cd_iframe.html
@@ -42,17 +42,17 @@ function onAttach(aState, aResponse)
       doCdParent,
       doCheckParent2];
   runTests(tests, testEnd);
 }
 
 function doCheckParent()
 {
   info("check parent window");
-  gState.client.evaluateJS("window.foobarObject.bug609872")
+  gState.webConsoleFront.evaluateJS("window.foobarObject.bug609872")
     .then(onFooObjectFromParent);
 }
 
 function onFooObjectFromParent(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "window.foobarObject.bug609872",
@@ -63,17 +63,17 @@ function onFooObjectFromParent(aResponse
   ok(!aResponse.helperResult, "no helper result");
 
   nextTest();
 }
 
 function doCdIframe()
 {
   info("test cd('iframe')");
-  gState.client.evaluateJS("cd('iframe')").then(onCdIframe);
+  gState.webConsoleFront.evaluateJS("cd('iframe')").then(onCdIframe);
 }
 
 function onCdIframe(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "cd('iframe')",
     result: { type: "undefined" },
@@ -83,17 +83,17 @@ function onCdIframe(aResponse)
   ok(!aResponse.exception, "no eval exception");
 
   nextTest();
 }
 
 function doCheckIframe()
 {
   info("check foobarObject from the iframe");
-  gState.client.evaluateJS("window.foobarObject.bug609872")
+  gState.webConsoleFront.evaluateJS("window.foobarObject.bug609872")
     .then(onFooObjectFromIframe);
 }
 
 function onFooObjectFromIframe(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "window.foobarObject.bug609872",
@@ -104,17 +104,17 @@ function onFooObjectFromIframe(aResponse
   ok(!aResponse.helperResult, "no helper result");
 
   nextTest();
 }
 
 function doCdContentIframe()
 {
   info("test cd('#content-iframe')");
-  gState.client.evaluateJS("cd('#content-iframe')").then(onCdContentIframe);
+  gState.webConsoleFront.evaluateJS("cd('#content-iframe')").then(onCdContentIframe);
 }
 
 function onCdContentIframe(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "cd('#content-iframe')",
     result: { type: "undefined" },
@@ -126,17 +126,17 @@ function onCdContentIframe(aResponse)
   nextTest();
 }
 function doCdSandboxedIframe()
 {
   // Don't use string to ensure we don't get security exception
   // when passing a content window reference.
   let cmd = "cd(document.getElementById('sandboxed-iframe').contentWindow)";
   info("test " + cmd);
-  gState.client.evaluateJS(cmd).then(onCdSandboxedIframe.bind(null, cmd));
+  gState.webConsoleFront.evaluateJS(cmd).then(onCdSandboxedIframe.bind(null, cmd));
 }
 
 function onCdSandboxedIframe(cmd, aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: cmd,
     result: { type: "undefined" },
@@ -146,17 +146,17 @@ function onCdSandboxedIframe(cmd, aRespo
   ok(!aResponse.exception, "no eval exception");
 
   nextTest();
 }
 
 function doCheckSandboxedIframe()
 {
   info("check foobarObject from the sandboxed iframe");
-  gState.client.evaluateJS("window.foobarObject.bug1051224")
+  gState.webConsoleFront.evaluateJS("window.foobarObject.bug1051224")
     .then(onFooObjectFromSandboxedIframe);
 }
 
 function onFooObjectFromSandboxedIframe(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "window.foobarObject.bug1051224",
@@ -167,17 +167,17 @@ function onFooObjectFromSandboxedIframe(
   ok(!aResponse.helperResult, "no helper result");
 
   nextTest();
 }
 
 function doCdParent()
 {
   info("test cd() back to parent");
-  gState.client.evaluateJS("cd()").then(onCdParent);
+  gState.webConsoleFront.evaluateJS("cd()").then(onCdParent);
 }
 
 function onCdParent(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "cd()",
     result: { type: "undefined" },
@@ -186,17 +186,17 @@ function onCdParent(aResponse)
 
   ok(!aResponse.exception, "no eval exception");
 
   nextTest();
 }
 
 function doCheckParent2()
 {
-  gState.client.evaluateJS("window.foobarObject.bug609872")
+  gState.webConsoleFront.evaluateJS("window.foobarObject.bug609872")
     .then(onFooObjectFromParent2);
 }
 
 function onFooObjectFromParent2(aResponse)
 {
   checkObject(aResponse, {
     from: gState.actor,
     input: "window.foobarObject.bug609872",
--- a/devtools/shared/webconsole/test/test_jsterm_last_result.html
+++ b/devtools/shared/webconsole/test/test_jsterm_last_result.html
@@ -13,17 +13,17 @@
 
 <iframe id="content-iframe" src="http://example.com/chrome/devtools/shared/webconsole/test/sandboxed_iframe.html"></iframe>
 
 <script class="testbody" type="text/javascript">
 SimpleTest.waitForExplicitFinish();
 let gState;
 
 function evaluateJS(input) {
-  return gState.client.evaluateJSAsync(input);
+  return gState.webConsoleFront.evaluateJSAsync(input);
 }
 
 function startTest()
 {
   removeEventListener("load", startTest);
   attachConsoleToTab([], state => {
     gState = state;
     let tests = [checkUndefinedResult,checkAdditionResult,checkObjectResult];
--- a/devtools/shared/webconsole/test/test_jsterm_queryselector.html
+++ b/devtools/shared/webconsole/test/test_jsterm_queryselector.html
@@ -12,17 +12,17 @@
 <p>Test for the querySelector / querySelectorAll helpers</p>
 
 <script class="testbody" type="text/javascript">
 SimpleTest.waitForExplicitFinish();
 let gState;
 let gWin;
 
 function evaluateJS(input) {
-  return gState.client.evaluateJS(input);
+  return gState.webConsoleFront.evaluateJS(input);
 }
 
 function startTest() {
   info ("Content window opened, attaching console to it");
 
   let systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
   ok (!gWin.document.nodePrincipal.equals(systemPrincipal),
       "The test document is not using the system principal");
--- a/devtools/shared/webconsole/test/test_network_get.html
+++ b/devtools/shared/webconsole/test/test_network_get.html
@@ -22,17 +22,17 @@ function startTest()
   attachConsoleToTab(["NetworkActivity"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   info("test network GET request");
 
   onNetworkEvent = onNetworkEvent.bind(null, aState);
-  aState.client.on("serverNetworkEvent", onNetworkEvent);
+  aState.webConsoleFront.on("serverNetworkEvent", onNetworkEvent);
   onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);
   aState.dbgClient.on("networkEventUpdate", onNetworkEventUpdate);
 
   let iframe = document.querySelector("iframe").contentWindow;
   iframe.wrappedJSObject.testXhrGet();
 }
 
 function onNetworkEvent(aState, aPacket)
@@ -45,17 +45,17 @@ function onNetworkEvent(aState, aPacket)
     actor: /[a-z]/,
     startedDateTime: /^\d+\-\d+\-\d+T.+$/,
     url: /data\.json/,
     method: "GET",
   });
 
   aState.netActor = netActor.actor;
 
-  aState.client.off("serverNetworkEvent", onNetworkEvent);
+  aState.webConsoleFront.off("serverNetworkEvent", onNetworkEvent);
 }
 
 let updates = [];
 
 function onNetworkEventUpdate(aState, aPacket)
 {
   info("received networkEventUpdate " + aPacket.updateType);
   is(aPacket.from, aState.netActor, "networkEventUpdate actor");
@@ -123,17 +123,17 @@ function onNetworkEventUpdate(aState, aP
   }
 
   if (updates.indexOf("responseContent") > -1 &&
       updates.indexOf("eventTimings") > -1) {
     aState.dbgClient.off("networkEventUpdate",
                                     onNetworkEventUpdate);
 
     onRequestHeaders = onRequestHeaders.bind(null, aState);
-    aState.client.getRequestHeaders(aState.netActor,
+    aState.webConsoleFront.getRequestHeaders(aState.netActor,
                                     onRequestHeaders);
   }
 }
 
 function onRequestHeaders(aState, aResponse)
 {
   info("checking request headers");
 
@@ -147,46 +147,46 @@ function onRequestHeaders(aState, aRespo
   });
 
   checkRawHeaders(aResponse.rawHeaders, {
     Referer: /network_requests_iframe\.html/,
     Cookie: /bug768096/,
   });
 
   onRequestCookies = onRequestCookies.bind(null, aState);
-  aState.client.getRequestCookies(aState.netActor,
+  aState.webConsoleFront.getRequestCookies(aState.netActor,
                                   onRequestCookies);
 }
 
 function onRequestCookies(aState, aResponse)
 {
   info("checking request cookies");
 
   is(aResponse.cookies.length, 3, "request cookies length");
 
   checkHeadersOrCookies(aResponse.cookies, {
     foobar: "fooval",
     omgfoo: "bug768096",
     badcookie: "bug826798=st3fan",
   });
 
   onRequestPostData = onRequestPostData.bind(null, aState);
-  aState.client.getRequestPostData(aState.netActor,
+  aState.webConsoleFront.getRequestPostData(aState.netActor,
                                    onRequestPostData);
 }
 
 function onRequestPostData(aState, aResponse)
 {
   info("checking request POST data");
 
   ok(!aResponse.postData.text, "no request POST data");
   ok(!aResponse.postDataDiscarded, "request POST data was not discarded");
 
   onResponseHeaders = onResponseHeaders.bind(null, aState);
-  aState.client.getResponseHeaders(aState.netActor,
+  aState.webConsoleFront.getResponseHeaders(aState.netActor,
                                    onResponseHeaders);
 }
 
 function onResponseHeaders(aState, aResponse)
 {
   info("checking response headers");
 
   ok(aResponse.headers.length > 0, "response headers > 0");
@@ -199,40 +199,40 @@ function onResponseHeaders(aState, aResp
   });
 
   checkRawHeaders(aResponse.rawHeaders, {
     "content-type": /^application\/(json|octet-stream)$/,
     "content-length": /^\d+$/,
   });
 
   onResponseCookies = onResponseCookies.bind(null, aState);
-  aState.client.getResponseCookies(aState.netActor,
+  aState.webConsoleFront.getResponseCookies(aState.netActor,
                                   onResponseCookies);
 }
 
 function onResponseCookies(aState, aResponse)
 {
   info("checking response cookies");
 
   is(aResponse.cookies.length, 0, "response cookies length");
 
   onResponseContent = onResponseContent.bind(null, aState);
-  aState.client.getResponseContent(aState.netActor,
+  aState.webConsoleFront.getResponseContent(aState.netActor,
                                    onResponseContent);
 }
 
 function onResponseContent(aState, aResponse)
 {
   info("checking response content");
 
   ok(aResponse.content.text, "response content text");
   ok(!aResponse.contentDiscarded, "response content was not discarded");
 
   onEventTimings = onEventTimings.bind(null, aState);
-  aState.client.getEventTimings(aState.netActor,
+  aState.webConsoleFront.getEventTimings(aState.netActor,
                                 onEventTimings);
 }
 
 function onEventTimings(aState, aResponse)
 {
   info("checking event timings");
 
   checkObject(aResponse, {
--- a/devtools/shared/webconsole/test/test_network_post.html
+++ b/devtools/shared/webconsole/test/test_network_post.html
@@ -23,17 +23,17 @@ function startTest()
   attachConsoleToTab(["NetworkActivity"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   info("test network POST request");
 
   onNetworkEvent = onNetworkEvent.bind(null, aState);
-  aState.client.on("serverNetworkEvent", onNetworkEvent);
+  aState.webConsoleFront.on("serverNetworkEvent", onNetworkEvent);
   onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);
   aState.dbgClient.on("networkEventUpdate", onNetworkEventUpdate);
 
   let iframe = document.querySelector("iframe").contentWindow;
   iframe.wrappedJSObject.testXhrPost();
 }
 
 function onNetworkEvent(aState, aPacket)
@@ -46,17 +46,17 @@ function onNetworkEvent(aState, aPacket)
     actor: /[a-z]/,
     startedDateTime: /^\d+\-\d+\-\d+T.+$/,
     url: /data\.json/,
     method: "POST",
   });
 
   aState.netActor = netActor.actor;
 
-  aState.client.off("serverNetworkEvent", onNetworkEvent);
+  aState.webConsoleFront.off("serverNetworkEvent", onNetworkEvent);
 }
 
 let updates = [];
 
 function onNetworkEventUpdate(aState, aPacket)
 {
   info("received networkEventUpdate " + aPacket.updateType);
   is(aPacket.from, aState.netActor, "networkEventUpdate actor");
@@ -125,17 +125,17 @@ function onNetworkEventUpdate(aState, aP
   }
 
   if (updates.indexOf("responseContent") > -1 &&
       updates.indexOf("eventTimings") > -1) {
     aState.dbgClient.off("networkEventUpdate",
                                     onNetworkEvent);
 
     onRequestHeaders = onRequestHeaders.bind(null, aState);
-    aState.client.getRequestHeaders(aState.netActor,
+    aState.webConsoleFront.getRequestHeaders(aState.netActor,
                                     onRequestHeaders);
   }
 }
 
 function onRequestHeaders(aState, aResponse)
 {
   info("checking request headers");
 
@@ -149,34 +149,34 @@ function onRequestHeaders(aState, aRespo
   });
 
   checkRawHeaders(aResponse.rawHeaders, {
     Referer: /network_requests_iframe\.html/,
     Cookie: /bug768096/,
   });
 
   onRequestCookies = onRequestCookies.bind(null, aState);
-  aState.client.getRequestCookies(aState.netActor,
+  aState.webConsoleFront.getRequestCookies(aState.netActor,
                                   onRequestCookies);
 }
 
 function onRequestCookies(aState, aResponse)
 {
   info("checking request cookies");
 
   is(aResponse.cookies.length, 3, "request cookies length");
 
   checkHeadersOrCookies(aResponse.cookies, {
     foobar: "fooval",
     omgfoo: "bug768096",
     badcookie: "bug826798=st3fan",
   });
 
   onRequestPostData = onRequestPostData.bind(null, aState);
-  aState.client.getRequestPostData(aState.netActor,
+  aState.webConsoleFront.getRequestPostData(aState.netActor,
                                    onRequestPostData);
 }
 
 function onRequestPostData(aState, aResponse)
 {
   info("checking request POST data");
 
   checkObject(aResponse, {
@@ -184,17 +184,17 @@ function onRequestPostData(aState, aResp
       text: /^Hello world! foobaz barr.+foobaz barr$/,
     },
     postDataDiscarded: false,
   });
 
   is(aResponse.postData.text.length, 552, "postData text length");
 
   onResponseHeaders = onResponseHeaders.bind(null, aState);
-  aState.client.getResponseHeaders(aState.netActor,
+  aState.webConsoleFront.getResponseHeaders(aState.netActor,
                                    onResponseHeaders);
 }
 
 function onResponseHeaders(aState, aResponse)
 {
   info("checking response headers");
 
   ok(aResponse.headers.length > 0, "response headers > 0");
@@ -207,44 +207,44 @@ function onResponseHeaders(aState, aResp
   });
 
   checkRawHeaders(aResponse.rawHeaders, {
     "content-type": /^application\/(json|octet-stream)$/,
     "content-length": /^\d+$/,
   });
 
   onResponseCookies = onResponseCookies.bind(null, aState);
-  aState.client.getResponseCookies(aState.netActor,
+  aState.webConsoleFront.getResponseCookies(aState.netActor,
                                   onResponseCookies);
 }
 
 function onResponseCookies(aState, aResponse)
 {
   info("checking response cookies");
 
   is(aResponse.cookies.length, 0, "response cookies length");
 
   onResponseContent = onResponseContent.bind(null, aState);
-  aState.client.getResponseContent(aState.netActor,
+  aState.webConsoleFront.getResponseContent(aState.netActor,
                                    onResponseContent);
 }
 
 function onResponseContent(aState, aResponse)
 {
   info("checking response content");
 
   checkObject(aResponse, {
     content: {
       text: /"test JSON data"/,
     },
     contentDiscarded: false,
   });
 
   onEventTimings = onEventTimings.bind(null, aState);
-  aState.client.getEventTimings(aState.netActor,
+  aState.webConsoleFront.getEventTimings(aState.netActor,
                                 onEventTimings);
 }
 
 function onEventTimings(aState, aResponse)
 {
   info("checking event timings");
 
   checkObject(aResponse, {
--- a/devtools/shared/webconsole/test/test_network_security-hpkp.html
+++ b/devtools/shared/webconsole/test/test_network_security-hpkp.html
@@ -90,16 +90,16 @@ function onNetworkEventUpdate(state, pac
     let data = TEST_CASES[gCurrentTestCase];
     is(received.securityInfo.hpkp, data.usesPinning,
       "Public Key Pinning detected correctly.");
 
     runNextCase(state);
   }
 
   if (packet.updateType === "securityInfo") {
-    state.client.getSecurityInfo(packet.from, onSecurityInfo);
+    state.webConsoleFront.getSecurityInfo(packet.from, onSecurityInfo);
   }
 }
 
 addEventListener("load", startTest);
 </script>
 </body>
 </html>
--- a/devtools/shared/webconsole/test/test_network_security-hsts.html
+++ b/devtools/shared/webconsole/test/test_network_security-hsts.html
@@ -85,16 +85,16 @@ function onNetworkEventUpdate(aState, aP
     let data = TEST_CASES[gCurrentTestCase];
     is(packet.securityInfo.hsts, data.usesHSTS,
       "Strict Transport Security detected correctly.");
 
     runNextCase(aState);
   }
 
   if (aPacket.updateType === "securityInfo") {
-    aState.client.getSecurityInfo(aPacket.from, onSecurityInfo);
+    aState.webConsoleFront.getSecurityInfo(aPacket.from, onSecurityInfo);
   }
 }
 
 addEventListener("load", startTest);
 </script>
 </body>
 </html>
--- a/devtools/shared/webconsole/test/test_nsiconsolemessage.html
+++ b/devtools/shared/webconsole/test/test_nsiconsolemessage.html
@@ -21,17 +21,17 @@ function startTest()
 {
   removeEventListener("load", startTest);
   attachConsole(["PageError"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onLogMessage = onLogMessage.bind(null, aState);
-  aState.client.on("logMessage", onLogMessage);
+  aState.webConsoleFront.on("logMessage", onLogMessage);
 
   expectedMessages = [{
     message: "hello world! bug859756",
     timeStamp: /^\d+$/,
   }];
 
   Services.console.logStringMessage("hello world! bug859756");
 
@@ -55,17 +55,17 @@ function onLogMessage(aState, aPacket)
     return;
   }
 
   receivedMessages.push(aPacket);
   if (receivedMessages.length != expectedMessages.length) {
     return;
   }
 
-  aState.client.off("logMessage", onLogMessage);
+  aState.webConsoleFront.off("logMessage", onLogMessage);
 
   checkObject(receivedMessages, expectedMessages);
 
   closeDebugger(aState, () => SimpleTest.finish());
 }
 
 addEventListener("load", startTest);
 </script>
--- a/devtools/shared/webconsole/test/test_object_actor.html
+++ b/devtools/shared/webconsole/test/test_object_actor.html
@@ -22,17 +22,17 @@ let expectedProps = [];
 function startTest() {
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(state, response) {
   onConsoleCall = onConsoleCall.bind(null, state);
-  state.client.on("consoleAPICall", onConsoleCall);
+  state.webConsoleFront.on("consoleAPICall", onConsoleCall);
 
   let longString = (new Array(DebuggerServer.LONG_STRING_LENGTH + 3)).join("\u0629");
 
   // Here we put the objects in the correct window, to avoid having them all
   // wrapped by proxies for cross-compartment access.
 
   let foobarObject = top.Object.create(null);
   foobarObject.tamarbuta = longString;
@@ -141,17 +141,17 @@ function onConsoleCall(state, aPacket) {
     filename: /test_object_actor/,
     functionName: "onAttach",
     arguments: ["hello", {
       type: "object",
       actor: /[a-z]/,
     }],
   });
 
-  state.client.off("consoleAPICall", onConsoleCall);
+  state.webConsoleFront.off("consoleAPICall", onConsoleCall);
 
   info("inspecting object properties");
   let args = aPacket.message.arguments;
   onProperties = onProperties.bind(null, state);
 
   let client = new ObjectClient(state.dbgClient, args[1]);
   client.getPrototypeAndProperties(onProperties);
 }
--- a/devtools/shared/webconsole/test/test_object_actor_native_getters.html
+++ b/devtools/shared/webconsole/test/test_object_actor_native_getters.html
@@ -22,17 +22,17 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onConsoleCall = onConsoleCall.bind(null, aState);
-  aState.client.on("consoleAPICall", onConsoleCall);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleCall);
 
   top.console.log("hello", document);
 
   expectedProps = {
     "location": {
       get: {
         type: "object",
         class: "Function",
@@ -62,17 +62,17 @@ function onConsoleCall(aState, aPacket)
     filename: /test_object_actor/,
     functionName: "onAttach",
     arguments: ["hello", {
       type: "object",
       actor: /[a-z]/,
     }],
   });
 
-  aState.client.off("consoleAPICall", onConsoleCall);
+  aState.webConsoleFront.off("consoleAPICall", onConsoleCall);
 
   info("inspecting object properties");
   let args = aPacket.message.arguments;
   onProperties = onProperties.bind(null, aState);
 
   let client = new ObjectClient(aState.dbgClient, args[1]);
   client.getPrototypeAndProperties(onProperties);
 }
--- a/devtools/shared/webconsole/test/test_object_actor_native_getters_lenient_this.html
+++ b/devtools/shared/webconsole/test/test_object_actor_native_getters_lenient_this.html
@@ -20,17 +20,17 @@ function startTest()
   removeEventListener("load", startTest);
 
   attachConsoleToTab(["ConsoleAPI"], onAttach);
 }
 
 function onAttach(aState, aResponse)
 {
   onConsoleCall = onConsoleCall.bind(null, aState);
-  aState.client.on("consoleAPICall", onConsoleCall);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleCall);
 
   let docAsProto = Object.create(document);
 
   top.console.log("hello", docAsProto);
 }
 
 function onConsoleCall(aState, aPacket)
 {
@@ -41,17 +41,17 @@ function onConsoleCall(aState, aPacket)
     filename: /test_object_actor/,
     functionName: "onAttach",
     arguments: ["hello", {
       type: "object",
       actor: /[a-z]/,
     }],
   });
 
-  aState.client.off("consoleAPICall", onConsoleCall);
+  aState.webConsoleFront.off("consoleAPICall", onConsoleCall);
 
   info("inspecting object properties");
   let args = aPacket.message.arguments;
   onProperties = onProperties.bind(null, aState);
 
   let client = new ObjectClient(aState.dbgClient, args[1]);
   client.getPrototypeAndProperties(onProperties);
 }
--- a/devtools/shared/webconsole/test/test_page_errors.html
+++ b/devtools/shared/webconsole/test/test_page_errors.html
@@ -148,34 +148,34 @@ function doPageErrors() {
 function startTest() {
   removeEventListener("load", startTest);
 
   attachConsole(["PageError"], onAttach);
 }
 
 function onAttach(state, response) {
   onPageError = onPageError.bind(null, state);
-  state.client.on("pageError", onPageError);
+  state.webConsoleFront.on("pageError", onPageError);
   doPageErrors();
 }
 
 let pageErrors = [];
 
 function onPageError(state, packet) {
   if (!packet.pageError.sourceName.includes("test_page_errors")) {
     info("Ignoring error from unknown source: " + packet.pageError.sourceName);
     return;
   }
 
   pageErrors.push(packet.pageError);
   if (pageErrors.length != Object.keys(expectedPageErrors).length) {
     return;
   }
 
-  state.client.off("pageError", onPageError);
+  state.webConsoleFront.off("pageError", onPageError);
 
   Object.values(expectedPageErrors).forEach(function(message, index) {
     info("checking received page error #" + index);
     checkObject(pageErrors[index], Object.values(expectedPageErrors)[index]);
   });
 
   closeDebugger(state, function() {
     SimpleTest.finish();
--- a/devtools/shared/webconsole/test/test_throw.html
+++ b/devtools/shared/webconsole/test/test_throw.html
@@ -22,56 +22,56 @@ function startTest()
 
 function onAttach(aState, aResponse)
 {
   let tests = [];
 
   let falsyValues = ["-0", "null", "undefined", "Infinity", "-Infinity", "NaN"];
   falsyValues.forEach(function(value) {
     tests.push(async function() {
-      const aResponse = await aState.client.evaluateJS("throw " + value + ";")
+      const aResponse = await aState.webConsoleFront.evaluateJS("throw " + value + ";")
       let type = aResponse.exception.type;
       is(type, value, "exception.type for throw " + value);
       nextTest();
     });
   });
 
   let identityTestValues = [false, 0];
   identityTestValues.forEach(function(value) {
     tests.push(async function() {
-      const aResponse = await aState.client.evaluateJS("throw " + value + ";")
+      const aResponse = await aState.webConsoleFront.evaluateJS("throw " + value + ";")
       let exception = aResponse.exception;
       is(exception, value, "response.exception for throw " + value);
       nextTest();
     });
   });
 
   let longString = Array(DebuggerServer.LONG_STRING_LENGTH + 1).join("a"),
       shortedString = longString.substring(0,
                         DebuggerServer.LONG_STRING_INITIAL_LENGTH
                       );
   tests.push(async function() {
-    const aResponse = await aState.client.evaluateJS("throw '" + longString + "';")
+    const aResponse = await aState.webConsoleFront.evaluateJS("throw '" + longString + "';")
     is(aResponse.exception.initial, shortedString,
       "exception.initial for throw longString"
     );
     is(aResponse.exceptionMessage.initial, shortedString,
       "exceptionMessage.initial for throw longString"
     );
     nextTest();
   });
 
   let symbolTestValues = [
     ["Symbol.iterator", "Symbol(Symbol.iterator)"],
     ["Symbol('foo')", "Symbol(foo)"],
     ["Symbol()", "Symbol()"],
   ];
   symbolTestValues.forEach(function([expr, message]) {
     tests.push(async function() {
-      const aResponse = await aState.client.evaluateJS("throw " + expr + ";");
+      const aResponse = await aState.webConsoleFront.evaluateJS("throw " + expr + ";");
       is(aResponse.exceptionMessage, message,
          "response.exception for throw " + expr);
       nextTest();
     });
   });
 
   runTests(tests, endTest.bind(null, aState));
 }