Bug 1495551 - Rename all "tab client" occurences to "target front". r=jdescottes
authorAlexandre Poirot <poirot.alex@gmail.com>
Tue, 16 Oct 2018 18:45:33 +0000
changeset 499984 8fee7620570b941294f056eab7fa220cc531669c
parent 499983 bb2acd046eae1fbedfe11348dc3f31530a645fd8
child 499985 e85db490e17a596a40eb8bc2a3d2787a77c41d50
push id1864
push userffxbld-merge
push dateMon, 03 Dec 2018 15:51:40 +0000
treeherdermozilla-release@f040763d99ad [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjdescottes
bugs1495551
milestone64.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 1495551 - Rename all "tab client" occurences to "target front". r=jdescottes MozReview-Commit-ID: JrEdamUz6Be Differential Revision: https://phabricator.services.mozilla.com/D8840
devtools/client/debugger/debugger-controller.js
devtools/client/debugger/new/test/mochitest/browser_dbg-chrome-debugging.js
devtools/client/debugger/test/mochitest/browser_dbg_listworkers.js
devtools/client/debugger/test/mochitest/browser_dbg_promises-chrome-allocation-stack.js
devtools/client/debugger/test/mochitest/browser_dbg_worker-window.js
devtools/client/debugger/test/mochitest/head.js
devtools/client/framework/target.js
devtools/client/netmonitor/src/har/har-automation.js
devtools/client/shared/test/browser_dbg_WorkerTargetActor.attach.js
devtools/client/shared/test/helper_workers.js
devtools/docs/backend/client-api.md
devtools/server/tests/mochitest/webconsole-helpers.js
devtools/server/tests/unit/head_dbg.js
devtools/server/tests/unit/test_attach.js
devtools/server/tests/unit/test_blackboxing-01.js
devtools/server/tests/unit/test_blackboxing-02.js
devtools/server/tests/unit/test_blackboxing-03.js
devtools/server/tests/unit/test_blackboxing-04.js
devtools/server/tests/unit/test_blackboxing-05.js
devtools/server/tests/unit/test_blackboxing-06.js
devtools/server/tests/unit/test_blackboxing-07.js
devtools/server/tests/unit/test_breakpoint-01.js
devtools/server/tests/unit/test_breakpoint-02.js
devtools/server/tests/unit/test_breakpoint-03.js
devtools/server/tests/unit/test_breakpoint-04.js
devtools/server/tests/unit/test_breakpoint-05.js
devtools/server/tests/unit/test_breakpoint-06.js
devtools/server/tests/unit/test_breakpoint-07.js
devtools/server/tests/unit/test_breakpoint-08.js
devtools/server/tests/unit/test_breakpoint-09.js
devtools/server/tests/unit/test_breakpoint-10.js
devtools/server/tests/unit/test_breakpoint-11.js
devtools/server/tests/unit/test_breakpoint-12.js
devtools/server/tests/unit/test_breakpoint-13.js
devtools/server/tests/unit/test_breakpoint-14.js
devtools/server/tests/unit/test_breakpoint-15.js
devtools/server/tests/unit/test_breakpoint-16.js
devtools/server/tests/unit/test_breakpoint-17.js
devtools/server/tests/unit/test_breakpoint-18.js
devtools/server/tests/unit/test_breakpoint-19.js
devtools/server/tests/unit/test_breakpoint-20.js
devtools/server/tests/unit/test_breakpoint-21.js
devtools/server/tests/unit/test_breakpoint-22.js
devtools/server/tests/unit/test_client_close.js
devtools/server/tests/unit/test_conditional_breakpoint-01.js
devtools/server/tests/unit/test_conditional_breakpoint-02.js
devtools/server/tests/unit/test_conditional_breakpoint-03.js
devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
devtools/server/tests/unit/test_eval-01.js
devtools/server/tests/unit/test_eval-02.js
devtools/server/tests/unit/test_eval-03.js
devtools/server/tests/unit/test_eval-04.js
devtools/server/tests/unit/test_eval-05.js
devtools/server/tests/unit/test_frameactor-01.js
devtools/server/tests/unit/test_frameactor-02.js
devtools/server/tests/unit/test_frameactor-03.js
devtools/server/tests/unit/test_frameactor-04.js
devtools/server/tests/unit/test_frameactor-05.js
devtools/server/tests/unit/test_frameactor_wasm-01.js
devtools/server/tests/unit/test_framearguments-01.js
devtools/server/tests/unit/test_framebindings-01.js
devtools/server/tests/unit/test_framebindings-02.js
devtools/server/tests/unit/test_framebindings-03.js
devtools/server/tests/unit/test_framebindings-04.js
devtools/server/tests/unit/test_framebindings-05.js
devtools/server/tests/unit/test_framebindings-06.js
devtools/server/tests/unit/test_framebindings-07.js
devtools/server/tests/unit/test_frameclient-01.js
devtools/server/tests/unit/test_frameclient-02.js
devtools/server/tests/unit/test_functiongrips-01.js
devtools/server/tests/unit/test_get-executable-lines-source-map.js
devtools/server/tests/unit/test_get-executable-lines.js
devtools/server/tests/unit/test_interrupt.js
devtools/server/tests/unit/test_listsources-01.js
devtools/server/tests/unit/test_listsources-02.js
devtools/server/tests/unit/test_listsources-03.js
devtools/server/tests/unit/test_longstringgrips-01.js
devtools/server/tests/unit/test_longstringgrips-02.js
devtools/server/tests/unit/test_nesting-01.js
devtools/server/tests/unit/test_nesting-02.js
devtools/server/tests/unit/test_nesting-03.js
devtools/server/tests/unit/test_new_source-01.js
devtools/server/tests/unit/test_new_source-02.js
devtools/server/tests/unit/test_objectgrips-01.js
devtools/server/tests/unit/test_objectgrips-02.js
devtools/server/tests/unit/test_objectgrips-03.js
devtools/server/tests/unit/test_objectgrips-04.js
devtools/server/tests/unit/test_objectgrips-05.js
devtools/server/tests/unit/test_objectgrips-06.js
devtools/server/tests/unit/test_objectgrips-07.js
devtools/server/tests/unit/test_objectgrips-08.js
devtools/server/tests/unit/test_objectgrips-09.js
devtools/server/tests/unit/test_objectgrips-10.js
devtools/server/tests/unit/test_objectgrips-11.js
devtools/server/tests/unit/test_objectgrips-12.js
devtools/server/tests/unit/test_objectgrips-13.js
devtools/server/tests/unit/test_objectgrips-14.js
devtools/server/tests/unit/test_objectgrips-15.js
devtools/server/tests/unit/test_pause_exceptions-01.js
devtools/server/tests/unit/test_pause_exceptions-02.js
devtools/server/tests/unit/test_pauselifetime-01.js
devtools/server/tests/unit/test_pauselifetime-02.js
devtools/server/tests/unit/test_pauselifetime-03.js
devtools/server/tests/unit/test_pauselifetime-04.js
devtools/server/tests/unit/test_promise_state-01.js
devtools/server/tests/unit/test_promise_state-02.js
devtools/server/tests/unit/test_promise_state-03.js
devtools/server/tests/unit/test_reattach-thread.js
devtools/server/tests/unit/test_setBreakpoint-at-the-beginning-of-a-line.js
devtools/server/tests/unit/test_setBreakpoint-at-the-end-of-a-line.js
devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-column.js
devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
devtools/server/tests/unit/test_setBreakpoint-on-line.js
devtools/server/tests/unit/test_source-01.js
devtools/server/tests/unit/test_sourcemaps-01.js
devtools/server/tests/unit/test_sourcemaps-02.js
devtools/server/tests/unit/test_sourcemaps-03.js
devtools/server/tests/unit/test_sourcemaps-04.js
devtools/server/tests/unit/test_sourcemaps-05.js
devtools/server/tests/unit/test_sourcemaps-06.js
devtools/server/tests/unit/test_sourcemaps-07.js
devtools/server/tests/unit/test_sourcemaps-08.js
devtools/server/tests/unit/test_sourcemaps-09.js
devtools/server/tests/unit/test_sourcemaps-10.js
devtools/server/tests/unit/test_sourcemaps-11.js
devtools/server/tests/unit/test_sourcemaps-12.js
devtools/server/tests/unit/test_sourcemaps-13.js
devtools/server/tests/unit/test_sourcemaps-16.js
devtools/server/tests/unit/test_sourcemaps-17.js
devtools/server/tests/unit/test_symbols-01.js
devtools/server/tests/unit/test_symbols-02.js
devtools/server/tests/unit/test_threadlifetime-01.js
devtools/server/tests/unit/test_threadlifetime-02.js
devtools/server/tests/unit/test_threadlifetime-03.js
devtools/server/tests/unit/test_threadlifetime-04.js
devtools/server/tests/unit/test_threadlifetime-05.js
devtools/server/tests/unit/test_threadlifetime-06.js
devtools/server/tests/unit/test_wasm_source-01.js
devtools/shared/webconsole/test/common.js
--- a/devtools/client/debugger/debugger-controller.js
+++ b/devtools/client/debugger/debugger-controller.js
@@ -463,50 +463,50 @@ var DebuggerController = {
 
 function Workers() {
   this._workerForms = Object.create(null);
   this._onWorkerListChanged = this._onWorkerListChanged.bind(this);
   this._onWorkerSelect = this._onWorkerSelect.bind(this);
 }
 
 Workers.prototype = {
-  get _tabClient() {
+  get _targetFront() {
     return DebuggerController._target.activeTab;
   },
 
   connect: function () {
     if (!Prefs.workersEnabled) {
       return;
     }
 
     this._updateWorkerList();
 
-    // `_tabClient` can be BrowsingContextTargetFront (protocol.js front) or
+    // `_targetFront` can be BrowsingContextTargetFront (protocol.js front) or
     // WorkerClient/DebuggerClient (old fashion client)
-    if (typeof(this._tabClient.on) == "function") {
-      this._tabClient.on("workerListChanged", this._onWorkerListChanged);
+    if (typeof(this._targetFront.on) == "function") {
+      this._targetFront.on("workerListChanged", this._onWorkerListChanged);
     } else {
-      this._tabClient.addListener("workerListChanged", this._onWorkerListChanged);
+      this._targetFront.addListener("workerListChanged", this._onWorkerListChanged);
     }
   },
 
   disconnect: function () {
-    if (typeof(this._tabClient.on) == "function") {
-      this._tabClient.off("workerListChanged", this._onWorkerListChanged);
+    if (typeof(this._targetFront.on) == "function") {
+      this._targetFront.off("workerListChanged", this._onWorkerListChanged);
     } else {
-      this._tabClient.removeListener("workerListChanged", this._onWorkerListChanged);
+      this._targetFront.removeListener("workerListChanged", this._onWorkerListChanged);
     }
   },
 
   _updateWorkerList: function () {
-    if (!this._tabClient.listWorkers) {
+    if (!this._targetFront.listWorkers) {
       return;
     }
 
-    this._tabClient.listWorkers().then((response) => {
+    this._targetFront.listWorkers().then((response) => {
       let workerForms = Object.create(null);
       for (let worker of response.workers) {
         workerForms[worker.actor] = worker;
       }
 
       for (let workerTargetActor in this._workerForms) {
         if (!(workerTargetActor in workerForms)) {
           DebuggerView.Workers.removeWorker(this._workerForms[workerTargetActor]);
--- a/devtools/client/debugger/new/test/mochitest/browser_dbg-chrome-debugging.js
+++ b/devtools/client/debugger/new/test/mochitest/browser_dbg-chrome-debugging.js
@@ -24,18 +24,18 @@ function initDebuggerClient() {
   DebuggerServer.registerAllActors();
   DebuggerServer.allowChromeProcess = true;
 
   let transport = DebuggerServer.connectPipe();
   return new DebuggerClient(transport);
 }
 
 async function attachThread(client, actor) {
-  let [response, tabClient] = await client.attachTarget(actor);
-  let [response2, threadClient] = await tabClient.attachThread(null);
+  let [response, targetFront] = await client.attachTarget(actor);
+  let [response2, threadClient] = await targetFront.attachThread(null);
   return threadClient;
 }
 
 function onNewSource(event, packet) {
   if (packet.source.url.startsWith("chrome:")) {
     ok(true, "Received a new chrome source: " + packet.source.url);
     gThreadClient.removeListener("newSource", onNewSource);
     gNewChromeSource.resolve();
--- a/devtools/client/debugger/test/mochitest/browser_dbg_listworkers.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_listworkers.js
@@ -7,53 +7,53 @@ function test() {
     DebuggerServer.init();
     DebuggerServer.registerAllActors();
 
     let client = new DebuggerClient(DebuggerServer.connectPipe());
     yield connect(client);
 
     let tab = yield addTab(TAB_URL);
     let { tabs } = yield listTabs(client);
-    let [, tabClient] = yield attachTarget(client, findTab(tabs, TAB_URL));
+    let [, targetFront] = yield attachTarget(client, findTab(tabs, TAB_URL));
 
-    let { workers } = yield listWorkers(tabClient);
+    let { workers } = yield listWorkers(targetFront);
     is(workers.length, 0);
 
     executeSoon(() => {
       evalInTab(tab, "var worker1 = new Worker('" + WORKER1_URL + "');");
     });
-    yield waitForWorkerListChanged(tabClient);
+    yield waitForWorkerListChanged(targetFront);
 
-    ({ workers } = yield listWorkers(tabClient));
+    ({ workers } = yield listWorkers(targetFront));
     is(workers.length, 1);
     is(workers[0].url, WORKER1_URL);
 
     executeSoon(() => {
       evalInTab(tab, "var worker2 = new Worker('" + WORKER2_URL + "');");
     });
-    yield waitForWorkerListChanged(tabClient);
+    yield waitForWorkerListChanged(targetFront);
 
-    ({ workers } = yield listWorkers(tabClient));
+    ({ workers } = yield listWorkers(targetFront));
     is(workers.length, 2);
     is(workers[0].url, WORKER1_URL);
     is(workers[1].url, WORKER2_URL);
 
     executeSoon(() => {
       evalInTab(tab, "worker1.terminate()");
     });
-    yield waitForWorkerListChanged(tabClient);
+    yield waitForWorkerListChanged(targetFront);
 
-    ({ workers } = yield listWorkers(tabClient));
+    ({ workers } = yield listWorkers(targetFront));
     is(workers.length, 1);
     is(workers[0].url, WORKER2_URL);
 
     executeSoon(() => {
       evalInTab(tab, "worker2.terminate()");
     });
-    yield waitForWorkerListChanged(tabClient);
+    yield waitForWorkerListChanged(targetFront);
 
-    ({ workers } = yield listWorkers(tabClient));
+    ({ workers } = yield listWorkers(targetFront));
     is(workers.length, 0);
 
     yield close(client);
     finish();
   });
 }
--- a/devtools/client/debugger/test/mochitest/browser_dbg_promises-chrome-allocation-stack.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_promises-chrome-allocation-stack.js
@@ -25,18 +25,18 @@ function test() {
 
     DebuggerServer.init();
     DebuggerServer.registerAllActors();
     DebuggerServer.allowChromeProcess = true;
 
     let client = new DebuggerClient(DebuggerServer.connectPipe());
     yield connect(client);
     let chrome = yield client.mainRoot.getProcess(0);
-    let [, tabClient] = yield attachTarget(client, chrome.form);
-    yield tabClient.attachThread();
+    let [, targetFront] = yield attachTarget(client, chrome.form);
+    yield targetFront.attachThread();
 
     yield testGetAllocationStack(client, chrome.form, () => {
       let p = new Promise(() => {});
       p.name = "p";
       let q = p.then();
       q.name = "q";
       let r = p.catch(() => {});
       r.name = "r";
--- a/devtools/client/debugger/test/mochitest/browser_dbg_worker-window.js
+++ b/devtools/client/debugger/test/mochitest/browser_dbg_worker-window.js
@@ -17,23 +17,23 @@ add_task(async function() {
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(client);
 
   let tab = await addTab(TAB_URL);
   let { tabs } = await listTabs(client);
-  let [, tabClient] = await attachTarget(client, findTab(tabs, TAB_URL));
+  let [, targetFront] = await attachTarget(client, findTab(tabs, TAB_URL));
 
-  await listWorkers(tabClient);
+  await listWorkers(targetFront);
   await createWorkerInTab(tab, WORKER_URL);
 
-  let { workers } = await listWorkers(tabClient);
-  let [, workerClient] = await attachWorker(tabClient,
+  let { workers } = await listWorkers(targetFront);
+  let [, workerClient] = await attachWorker(targetFront,
                                              findWorker(workers, WORKER_URL));
 
   let toolbox = await gDevTools.showToolbox(TargetFactory.forWorker(workerClient),
                                             "jsdebugger",
                                             Toolbox.HostType.WINDOW);
 
   is(toolbox.hostType, "window", "correct host");
 
--- a/devtools/client/debugger/test/mochitest/head.js
+++ b/devtools/client/debugger/test/mochitest/head.js
@@ -1084,34 +1084,34 @@ function findTab(tabs, url) {
   return null;
 }
 
 function attachTarget(client, tab) {
   info("Attaching to tab with url '" + tab.url + "'.");
   return client.attachTarget(tab.actor);
 }
 
-function listWorkers(tabClient) {
+function listWorkers(targetFront) {
   info("Listing workers.");
-  return tabClient.listWorkers();
+  return targetFront.listWorkers();
 }
 
 function findWorker(workers, url) {
   info("Finding worker with url '" + url + "'.");
   for (let worker of workers) {
     if (worker.url === url) {
       return worker;
     }
   }
   return null;
 }
 
-function attachWorker(tabClient, worker) {
+function attachWorker(targetFront, worker) {
   info("Attaching to worker with url '" + worker.url + "'.");
-  return tabClient.attachWorker(worker.actor);
+  return targetFront.attachWorker(worker.actor);
 }
 
 function waitForWorkerListChanged(targetFront) {
   info("Waiting for worker list to change.");
   return targetFront.once("workerListChanged");
 }
 
 function attachThread(workerClient, options) {
@@ -1278,25 +1278,25 @@ async function initWorkerDebugger(TAB_UR
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
   let client = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(client);
 
   let tab = await addTab(TAB_URL);
   let { tabs } = await listTabs(client);
-  let [, tabClient] = await attachTarget(client, findTab(tabs, TAB_URL));
+  let [, targetFront] = await attachTarget(client, findTab(tabs, TAB_URL));
 
   await createWorkerInTab(tab, WORKER_URL);
 
-  let { workers } = await listWorkers(tabClient);
-  let [, workerClient] = await attachWorker(tabClient,
+  let { workers } = await listWorkers(targetFront);
+  let [, workerClient] = await attachWorker(targetFront,
                                              findWorker(workers, WORKER_URL));
 
   let toolbox = await gDevTools.showToolbox(TargetFactory.forWorker(workerClient),
                                             "jsdebugger",
                                             Toolbox.HostType.WINDOW);
 
   let debuggerPanel = toolbox.getCurrentPanel();
   let gDebugger = debuggerPanel.panelWin;
 
-  return {client, tab, tabClient, workerClient, toolbox, gDebugger};
+  return {client, tab, targetFront, workerClient, toolbox, gDebugger};
 }
--- a/devtools/client/framework/target.js
+++ b/devtools/client/framework/target.js
@@ -511,18 +511,18 @@ TabTarget.prototype = {
    */
   attach() {
     if (this._attach) {
       return this._attach;
     }
 
     // Attach the target actor
     const attachTarget = async () => {
-      const [response, tabClient] = await this._client.attachTarget(this._form.actor);
-      this.activeTab = tabClient;
+      const [response, targetFront] = await this._client.attachTarget(this._form.actor);
+      this.activeTab = targetFront;
       this.threadActor = response.threadActor;
 
       this.activeTab.on("tabNavigated", this._onTabNavigated);
       this._onFrameUpdate = packet => {
         this.emit("frame-update", packet);
       };
       this.activeTab.on("frameUpdate", this._onFrameUpdate);
     };
@@ -852,20 +852,20 @@ function WorkerTarget(workerClient) {
   EventEmitter.decorate(this);
   this._workerClient = workerClient;
 }
 
 /**
  * A WorkerTarget represents a worker. Unlike TabTarget, which can represent
  * either a local or remote tab, WorkerTarget always represents a remote worker.
  * Moreover, unlike TabTarget, which is constructed with a placeholder object
- * for remote tabs (from which a TabClient can then be lazily obtained),
+ * for remote tabs (from which a TargetFront can then be lazily obtained),
  * WorkerTarget is constructed with a WorkerClient directly.
  *
- * WorkerClient is designed to mimic the interface of TabClient as closely as
+ * WorkerClient is designed to mimic the interface of TargetFront as closely as
  * possible. This allows us to debug workers as if they were ordinary tabs,
  * requiring only minimal changes to the rest of the frontend.
  */
 WorkerTarget.prototype = {
   get isRemote() {
     return true;
   },
 
--- a/devtools/client/netmonitor/src/har/har-automation.js
+++ b/devtools/client/netmonitor/src/har/har-automation.js
@@ -65,17 +65,17 @@ HarAutomation.prototype = {
       return;
     }
 
     if (!tabGrip) {
       return;
     }
 
     this.debuggerClient = client;
-    this.tabClient = this.toolbox.target.activeTab;
+    this.targetFront = this.toolbox.target.activeTab;
     this.webConsoleClient = this.toolbox.target.activeConsole;
 
     this.tabWatcher = new TabWatcher(this.toolbox, this);
     this.tabWatcher.connect();
   },
 
   pageLoadBegin: function(response) {
     this.resetCollector();
--- a/devtools/client/shared/test/browser_dbg_WorkerTargetActor.attach.js
+++ b/devtools/client/shared/test/browser_dbg_WorkerTargetActor.attach.js
@@ -29,50 +29,50 @@ function test() {
     DebuggerServer.init();
     DebuggerServer.registerAllActors();
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     yield connect(client);
 
     const tab = yield addTab(TAB1_URL);
     const { tabs } = yield listTabs(client);
-    const [, tabClient] = yield attachTarget(client, findTab(tabs, TAB1_URL));
-    yield listWorkers(tabClient);
+    const [, targetFront] = yield attachTarget(client, findTab(tabs, TAB1_URL));
+    yield listWorkers(targetFront);
 
     // If a page still has pending network requests, it will not be moved into
     // the bfcache. Consequently, we cannot use waitForWorkerListChanged here,
     // because the worker is not guaranteed to have finished loading when it is
     // registered. Instead, we have to wait for the promise returned by
     // createWorker in the tab to be resolved.
     yield createWorkerInTab(tab, WORKER1_URL);
-    let { workers } = yield listWorkers(tabClient);
-    let [, workerClient1] = yield attachWorker(tabClient,
+    let { workers } = yield listWorkers(targetFront);
+    let [, workerClient1] = yield attachWorker(targetFront,
                                                findWorker(workers, WORKER1_URL));
     is(workerClient1.isClosed, false, "worker in tab 1 should not be closed");
 
     executeSoon(() => {
       BrowserTestUtils.loadURI(tab.linkedBrowser, TAB2_URL);
     });
     yield waitForWorkerClose(workerClient1);
     is(workerClient1.isClosed, true, "worker in tab 1 should be closed");
 
     yield createWorkerInTab(tab, WORKER2_URL);
-    ({ workers } = yield listWorkers(tabClient));
-    const [, workerClient2] = yield attachWorker(tabClient,
+    ({ workers } = yield listWorkers(targetFront));
+    const [, workerClient2] = yield attachWorker(targetFront,
                                                findWorker(workers, WORKER2_URL));
     is(workerClient2.isClosed, false, "worker in tab 2 should not be closed");
 
     executeSoon(() => {
       tab.linkedBrowser.goBack();
     });
     yield waitForWorkerClose(workerClient2);
     is(workerClient2.isClosed, true, "worker in tab 2 should be closed");
 
-    ({ workers } = yield listWorkers(tabClient));
-    [, workerClient1] = yield attachWorker(tabClient,
+    ({ workers } = yield listWorkers(targetFront));
+    [, workerClient1] = yield attachWorker(targetFront,
                                            findWorker(workers, WORKER1_URL));
     is(workerClient1.isClosed, false, "worker in tab 1 should not be closed");
 
     yield close(client);
     SpecialPowers.setIntPref(MAX_TOTAL_VIEWERS, oldMaxTotalViewers);
     finish();
   });
 }
--- a/devtools/client/shared/test/helper_workers.js
+++ b/devtools/client/shared/test/helper_workers.js
@@ -93,34 +93,34 @@ function findTab(tabs, url) {
   return null;
 }
 
 function attachTarget(client, tab) {
   info("Attaching to tab with url '" + tab.url + "'.");
   return client.attachTarget(tab.actor);
 }
 
-function listWorkers(tabClient) {
+function listWorkers(targetFront) {
   info("Listing workers.");
-  return tabClient.listWorkers();
+  return targetFront.listWorkers();
 }
 
 function findWorker(workers, url) {
   info("Finding worker with url '" + url + "'.");
   for (const worker of workers) {
     if (worker.url === url) {
       return worker;
     }
   }
   return null;
 }
 
-function attachWorker(tabClient, worker) {
+function attachWorker(targetFront, worker) {
   info("Attaching to worker with url '" + worker.url + "'.");
-  return tabClient.attachWorker(worker.actor);
+  return targetFront.attachWorker(worker.actor);
 }
 
 function attachThread(workerClient, options) {
   info("Attaching to thread.");
   return workerClient.attachThread(options);
 }
 
 async function waitForWorkerClose(workerClient) {
@@ -154,35 +154,35 @@ async function initWorkerDebugger(TAB_UR
   DebuggerServer.init();
   DebuggerServer.registerAllActors();
 
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(client);
 
   const tab = await addTab(TAB_URL);
   const { tabs } = await listTabs(client);
-  const [, tabClient] = await attachTarget(client, findTab(tabs, TAB_URL));
+  const [, targetFront] = await attachTarget(client, findTab(tabs, TAB_URL));
 
   await createWorkerInTab(tab, WORKER_URL);
 
-  const { workers } = await listWorkers(tabClient);
-  const [, workerClient] = await attachWorker(tabClient,
+  const { workers } = await listWorkers(targetFront);
+  const [, workerClient] = await attachWorker(targetFront,
                                              findWorker(workers, WORKER_URL));
 
   const toolbox = await gDevTools.showToolbox(TargetFactory.forWorker(workerClient),
                                             "jsdebugger",
                                             Toolbox.HostType.WINDOW);
 
   const debuggerPanel = toolbox.getCurrentPanel();
 
   const gDebugger = debuggerPanel.panelWin;
 
   const context = createDebuggerContext(toolbox);
 
-  return { ...context, client, tab, tabClient, workerClient, toolbox, gDebugger};
+  return { ...context, client, tab, targetFront, workerClient, toolbox, gDebugger};
 }
 
 // Override addTab/removeTab as defined by shared-head, since these have
 // an extra window parameter and add a frame script
 this.addTab = function addTab(url, win) {
   info("Adding tab: " + url);
 
   const deferred = getDeferredPromise().defer();
--- a/devtools/docs/backend/client-api.md
+++ b/devtools/docs/backend/client-api.md
@@ -73,42 +73,42 @@ Attaching to a browser tab requires enum
 ```javascript
 function attachToTab() {
   // Get the list of tabs to find the one to attach to.
   client.listTabs().then((response) => {
     // Find the active tab.
     let tab = response.tabs[response.selected];
 
     // Attach to the tab.
-    client.attachTarget(tab.actor).then(([response, tabClient]) => {
-      if (!tabClient) {
+    client.attachTarget(tab.actor).then(([response, targetFront]) => {
+      if (!targetFront) {
         return;
       }
 
-      // Now the tabClient is ready and can be used.
+      // Now the targetFront is ready and can be used.
 
       // Attach listeners for client events.
-      tabClient.addListener("tabNavigated", onTab);
+      targetFront.addListener("tabNavigated", onTab);
     });
   });
 }
 ```
 
 The debugger client will send event notifications for a number of events the application may be interested in. These events include state changes in the debugger, like pausing and resuming, stack frames or source scripts being ready for retrieval, etc.
 
 ## Handling location changes
 
 When the user navigates away from a page, a `tabNavigated` event will be fired. The proper way to handle this event is to detach from the previous thread and tab and attach to the new ones:
 
 ```javascript
 async function onTab() {
   // Detach from the previous thread.
   await client.activeThread.detach();
   // Detach from the previous tab.
-  await tabClient.activeTab.detach();
+  await targetFront.activeTab.detach();
   // Start debugging the new tab.
   start();
 }
 ```
 
 ## Debugging JavaScript running in a browser tab
 
 Once the application is attached to a tab, it can attach to its thread in order to interact with the JavaScript debugger:
@@ -181,18 +181,18 @@ function shutdownDebugger() {
  * Start debugging the current tab.
  */
 function debugTab() {
   // Get the list of tabs to find the one to attach to.
   client.listTabs().then(response => {
     // Find the active tab.
     let tab = response.tabs[response.selected];
     // Attach to the tab.
-    client.attachTarget(tab.actor).then(([response, tabClient]) => {
-      if (!tabClient) {
+    client.attachTarget(tab.actor).then(([response, targetFront]) => {
+      if (!targetFront) {
         return;
       }
 
       // Attach to the thread (context).
       client.attachThread(response.threadActor, (response, thread) => {
         if (!thread) {
           return;
         }
--- a/devtools/server/tests/mochitest/webconsole-helpers.js
+++ b/devtools/server/tests/mochitest/webconsole-helpers.js
@@ -24,17 +24,17 @@ 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
- *           - tabClient: the tab client
+ *           - targetFront: the target front
  *           - consoleClient: the console client
  *           - cleanup: a generator function which can be called to close
  *             the opened tab and disconnect its debugger client.
  */
 async function attachURL(url) {
   let win = window.open(url, "_blank");
   let client = null;
 
@@ -54,18 +54,18 @@ async function attachURL(url) {
   await client.connect();
   const {tabs} = await client.listTabs();
   const attachedTab = tabs.find(tab => tab.url === url);
 
   if (!attachedTab) {
     throw new Error(`Could not find a tab matching URL ${url}`);
   }
 
-  const [, tabClient] = await client.attachTarget(attachedTab.actor);
+  const [, targetFront] = await client.attachTarget(attachedTab.actor);
   const [, consoleClient] = await client.attachConsole(attachedTab.consoleActor, []);
 
   return {
     tab: attachedTab,
-    tabClient,
+    targetFront,
     consoleClient,
     cleanup,
   };
 }
--- a/devtools/server/tests/unit/head_dbg.js
+++ b/devtools/server/tests/unit/head_dbg.js
@@ -185,19 +185,19 @@ function attachTarget(client, tab) {
 
 function waitForNewSource(threadClient, url) {
   dump("Waiting for new source with url '" + url + "'.\n");
   return waitForEvent(threadClient, "newSource", function(packet) {
     return packet.source.url === url;
   });
 }
 
-function attachThread(tabClient, options = {}) {
+function attachThread(targetFront, options = {}) {
   dump("Attaching to thread.\n");
-  return tabClient.attachThread(options);
+  return targetFront.attachThread(options);
 }
 
 function resume(threadClient) {
   dump("Resuming thread.\n");
   return threadClient.resume();
 }
 
 function getSources(threadClient) {
@@ -350,51 +350,51 @@ function getTestTab(client, title, callb
         return;
       }
     }
     callback(null);
   });
 }
 
 // Attach to |client|'s tab whose title is |title|; pass |callback| the
-// response packet and a TabClient instance referring to that tab.
+// response packet and a TargetFront instance referring to that tab.
 function attachTestTab(client, title, callback) {
   getTestTab(client, title, function(tab) {
-    client.attachTarget(tab.actor).then(([response, tabClient]) => {
-      callback(response, tabClient);
+    client.attachTarget(tab.actor).then(([response, targetFront]) => {
+      callback(response, targetFront);
     });
   });
 }
 
 // Attach to |client|'s tab whose title is |title|, and then attach to
 // that tab's thread. Pass |callback| the thread attach response packet, a
-// TabClient referring to the tab, and a ThreadClient referring to the
+// TargetFront referring to the tab, and a ThreadClient referring to the
 // thread.
 function attachTestThread(client, title, callback) {
-  attachTestTab(client, title, function(tabResponse, tabClient) {
+  attachTestTab(client, title, function(tabResponse, targetFront) {
     function onAttach([response, threadClient]) {
-      callback(response, tabClient, threadClient, tabResponse);
+      callback(response, targetFront, threadClient, tabResponse);
     }
-    tabClient.attachThread({
+    targetFront.attachThread({
       useSourceMaps: true,
       autoBlackBox: true
     }).then(onAttach);
   });
 }
 
 // Attach to |client|'s tab whose title is |title|, attach to the tab's
 // thread, and then resume it. Pass |callback| the thread's response to
-// the 'resume' packet, a TabClient for the tab, and a ThreadClient for the
+// the 'resume' packet, a TargetFront for the tab, and a ThreadClient for the
 // thread.
 function attachTestTabAndResume(client, title, callback = () => {}) {
   return new Promise((resolve) => {
-    attachTestThread(client, title, function(response, tabClient, threadClient) {
+    attachTestThread(client, title, function(response, targetFront, threadClient) {
       threadClient.resume(function(response) {
-        callback(response, tabClient, threadClient);
-        resolve([response, tabClient, threadClient]);
+        callback(response, targetFront, threadClient);
+        resolve([response, targetFront, threadClient]);
       });
     });
   });
 }
 
 /**
  * Initialize the testing debugger server.
  */
@@ -857,19 +857,19 @@ async function setupTestFromUrl(url) {
   const global = createTestGlobal("test");
   DebuggerServer.addTestGlobal(global);
 
   const debuggerClient = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(debuggerClient);
 
   const { tabs } = await listTabs(debuggerClient);
   const tab = findTab(tabs, "test");
-  const [, tabClient] = await attachTarget(debuggerClient, tab);
+  const [, targetFront] = await attachTarget(debuggerClient, tab);
 
-  const [, threadClient] = await attachThread(tabClient);
+  const [, threadClient] = await attachThread(targetFront);
   await resume(threadClient);
 
   const sourceUrl = getFileUrl(url);
   const promise = waitForNewSource(threadClient, sourceUrl);
   loadSubScript(sourceUrl, global);
   const { source } = await promise;
 
   const sourceClient = threadClient.source(source);
--- a/devtools/server/tests/unit/test_attach.js
+++ b/devtools/server/tests/unit/test_attach.js
@@ -9,25 +9,25 @@ var gDebuggee;
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   const transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(function([type, traits]) {
-    attachTestTab(gClient, "test-1", function(reply, tabClient) {
-      test_attach(tabClient);
+    attachTestTab(gClient, "test-1", function(reply, targetFront) {
+      test_attach(targetFront);
     });
   });
   do_test_pending();
 }
 
-function test_attach(tabClient) {
-  tabClient.attachThread({}).then(function([response, threadClient]) {
+function test_attach(targetFront) {
+  targetFront.attachThread({}).then(function([response, threadClient]) {
     Assert.equal(threadClient.state, "paused");
     threadClient.resume(cleanup);
   });
 }
 
 function cleanup() {
   gClient.addListener("closed", function(event) {
     do_test_finished();
--- a/devtools/server/tests/unit/test_blackboxing-01.js
+++ b/devtools/server/tests/unit/test_blackboxing-01.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-black-box",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testBlackBox();
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
--- a/devtools/server/tests/unit/test_blackboxing-02.js
+++ b/devtools/server/tests/unit/test_blackboxing-02.js
@@ -16,17 +16,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-black-box",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_black_box();
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
--- a/devtools/server/tests/unit/test_blackboxing-03.js
+++ b/devtools/server/tests/unit/test_blackboxing-03.js
@@ -14,17 +14,17 @@ var gThreadClient;
 var gBpClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-black-box",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_black_box();
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
--- a/devtools/server/tests/unit/test_blackboxing-04.js
+++ b/devtools/server/tests/unit/test_blackboxing-04.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-black-box",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_black_box();
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/blackboxme.js";
--- a/devtools/server/tests/unit/test_blackboxing-05.js
+++ b/devtools/server/tests/unit/test_blackboxing-05.js
@@ -14,17 +14,17 @@ var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-black-box",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         // XXX: We have to do an executeSoon so that the error isn't caught and
         // reported by DebuggerClient.requester (because we are using the local
         // transport and share a stack) which causes the test to fail.
         Services.tm.dispatchToMainThread({
           run: test_black_box
         });
       });
--- a/devtools/server/tests/unit/test_blackboxing-06.js
+++ b/devtools/server/tests/unit/test_blackboxing-06.js
@@ -16,17 +16,17 @@ const {SourceNode} = require("source-map
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-black-box",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
 
         Promise.resolve(setup_code())
           .then(black_box_code)
           .then(run_code)
           .then(test_correct_location)
           .catch(function(error) {
             Assert.ok(false, "Should not get an error, got " + error);
--- a/devtools/server/tests/unit/test_blackboxing-07.js
+++ b/devtools/server/tests/unit/test_blackboxing-07.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-black-box");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-black-box",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testBlackBox();
                            });
   });
   do_test_pending();
 }
 
 const BLACK_BOXED_URL = "http://example.com/black-boxed.min.js";
--- a/devtools/server/tests/unit/test_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_breakpoint-01.js
@@ -21,17 +21,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
 }
 
 function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_breakpoint-02.js
@@ -22,17 +22,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_breakpoint_running();
                            });
   });
 }
 
 function test_breakpoint_running() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_breakpoint-03.js
@@ -25,17 +25,17 @@ function run_test() {
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_skip_breakpoint();
                            });
   });
 }
 
 var test_no_skip_breakpoint = async function(source, location) {
   const [response, bpClient] = await source.setBreakpoint(
--- a/devtools/server/tests/unit/test_breakpoint-04.js
+++ b/devtools/server/tests/unit/test_breakpoint-04.js
@@ -22,17 +22,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_breakpoint();
                            });
   });
 }
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-05.js
+++ b/devtools/server/tests/unit/test_breakpoint-05.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_skip_breakpoint();
                            });
   });
 }
 
 function test_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-06.js
+++ b/devtools/server/tests/unit/test_breakpoint-06.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_nested_breakpoint();
                            });
   });
 }
 
 function test_nested_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-07.js
+++ b/devtools/server/tests/unit/test_breakpoint-07.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_second_child_skip_breakpoint();
                            });
   });
 }
 
 function test_second_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-08.js
+++ b/devtools/server/tests/unit/test_breakpoint-08.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_skip_breakpoint();
                            });
   });
 }
 
 function test_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-09.js
+++ b/devtools/server/tests/unit/test_breakpoint-09.js
@@ -22,17 +22,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_remove_breakpoint();
                            });
   });
 }
 
 function test_remove_breakpoint() {
   let done = false;
--- a/devtools/server/tests/unit/test_breakpoint-10.js
+++ b/devtools/server/tests/unit/test_breakpoint-10.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_breakpoint();
                            });
   });
 }
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-11.js
+++ b/devtools/server/tests/unit/test_breakpoint-11.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_breakpoint();
                            });
   });
 }
 
 function test_child_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-12.js
+++ b/devtools/server/tests/unit/test_breakpoint-12.js
@@ -27,17 +27,17 @@ function run_test() {
 function run_test_with_server(server, callback) {
   gCallback = callback;
   gCount = 1;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_child_skip_breakpoint();
                            });
   });
 }
 
 function test_child_skip_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-13.js
+++ b/devtools/server/tests/unit/test_breakpoint-13.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
 }
 
 function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-14.js
+++ b/devtools/server/tests/unit/test_breakpoint-14.js
@@ -23,17 +23,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-stack", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
 }
 
 function test_simple_breakpoint() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_breakpoint-15.js
+++ b/devtools/server/tests/unit/test_breakpoint-15.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testSameBreakpoint();
                            });
   });
   do_test_pending();
 }
 
 const SOURCE_URL = "http://example.com/source.js";
--- a/devtools/server/tests/unit/test_breakpoint-16.js
+++ b/devtools/server/tests/unit/test_breakpoint-16.js
@@ -23,17 +23,17 @@ function run_test() {
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_column_breakpoint();
                            });
   });
 }
 
 function test_column_breakpoint() {
   // Debugger statement
--- a/devtools/server/tests/unit/test_breakpoint-17.js
+++ b/devtools/server/tests/unit/test_breakpoint-17.js
@@ -21,17 +21,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_breakpoints_columns();
                            });
   });
 }
 
 const code =
 "(" + function(global) {
--- a/devtools/server/tests/unit/test_breakpoint-18.js
+++ b/devtools/server/tests/unit/test_breakpoint-18.js
@@ -24,17 +24,17 @@ function run_test_with_server(server, ca
   gCallback = callback;
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gDebuggee.console = { log: x => void x };
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              setUpCode();
                            });
   });
 }
 
 function setUpCode() {
   gClient.addOneTimeListener("paused", setBreakpoint);
--- a/devtools/server/tests/unit/test_breakpoint-19.js
+++ b/devtools/server/tests/unit/test_breakpoint-19.js
@@ -22,17 +22,17 @@ function run_test() {
 function run_test_with_server(server, callback) {
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gDebuggee.console = { log: x => void x };
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testBreakpoint();
                            });
   });
 }
 
 const URL = "test.js";
 
--- a/devtools/server/tests/unit/test_breakpoint-20.js
+++ b/devtools/server/tests/unit/test_breakpoint-20.js
@@ -16,17 +16,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-breakpoints");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestThread(gClient, "test-breakpoints", testBreakpoint);
   });
   do_test_pending();
 }
 
-const testBreakpoint = async function(threadResponse, tabClient,
+const testBreakpoint = async function(threadResponse, targetFront,
                                              threadClient, tabResponse) {
   evalSetupCode();
 
   // Load the test source once.
 
   evalTestCode();
   equal(gDebuggee.functions.length, 1,
         "The test code should have added a function.");
--- a/devtools/server/tests/unit/test_breakpoint-21.js
+++ b/devtools/server/tests/unit/test_breakpoint-21.js
@@ -22,17 +22,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
 const test = async function() {
   // Populate the `ScriptStore` so that we only test that the script
--- a/devtools/server/tests/unit/test_breakpoint-22.js
+++ b/devtools/server/tests/unit/test_breakpoint-22.js
@@ -21,17 +21,17 @@ function run_test() {
 
 function run_test_with_server(server, callback) {
   initTestDebuggerServer(server);
   gDebuggee = addTestGlobal("test-breakpoints", server);
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient,
                            "test-breakpoints",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test();
                            });
   });
 }
 
 const test = async function() {
   // Populate the `ScriptStore` so that we only test that the script
--- a/devtools/server/tests/unit/test_client_close.js
+++ b/devtools/server/tests/unit/test_client_close.js
@@ -9,17 +9,17 @@ var gDebuggee;
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   const transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(function(type, traits) {
-    attachTestTab(gClient, "test-1", function(reply, tabClient) {
+    attachTestTab(gClient, "test-1", function(reply, targetFront) {
       test_close(transport);
     });
   });
   do_test_pending();
 }
 
 function test_close(transport) {
   // Check that, if we fake a transport shutdown
--- a/devtools/server/tests/unit/test_conditional_breakpoint-01.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-01.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-conditional-breakpoint",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_breakpoint() {
--- a/devtools/server/tests/unit/test_conditional_breakpoint-02.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-conditional-breakpoint",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_breakpoint() {
--- a/devtools/server/tests/unit/test_conditional_breakpoint-03.js
+++ b/devtools/server/tests/unit/test_conditional_breakpoint-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-conditional-breakpoint");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-conditional-breakpoint",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_breakpoint();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_breakpoint() {
--- a/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
+++ b/devtools/server/tests/unit/test_dbgclient_debuggerstatement.js
@@ -1,36 +1,36 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 var gClient;
-var gTabClient;
+var gTargetFront;
 var gDebuggee;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-1");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   const transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(function([type, traits]) {
-    attachTestTab(gClient, "test-1", function(reply, tabClient) {
-      gTabClient = tabClient;
+    attachTestTab(gClient, "test-1", function(reply, targetFront) {
+      gTargetFront = targetFront;
       test_threadAttach(reply.threadActor);
     });
   });
   do_test_pending();
 }
 
 function test_threadAttach(threadActorID) {
   info("Trying to attach to thread " + threadActorID);
-  gTabClient.attachThread({}).then(function([response, threadClient]) {
+  gTargetFront.attachThread({}).then(function([response, threadClient]) {
     Assert.equal(threadClient.state, "paused");
     Assert.equal(threadClient.actor, threadActorID);
     threadClient.resume(function() {
       Assert.equal(threadClient.state, "attached");
       test_debugger_statement(threadClient);
     });
   });
 }
--- a/devtools/server/tests/unit/test_eval-01.js
+++ b/devtools/server/tests/unit/test_eval-01.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_eval();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_eval() {
--- a/devtools/server/tests/unit/test_eval-02.js
+++ b/devtools/server/tests/unit/test_eval-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_throw_eval();
                            });
   });
   do_test_pending();
 }
 
 function test_throw_eval() {
--- a/devtools/server/tests/unit/test_eval-03.js
+++ b/devtools/server/tests/unit/test_eval-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_syntax_error_eval();
                            });
   });
   do_test_pending();
 }
 
 function test_syntax_error_eval() {
--- a/devtools/server/tests/unit/test_eval-04.js
+++ b/devtools/server/tests/unit/test_eval-04.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_different_frames_eval();
                            });
   });
   do_test_pending();
 }
 
 function test_different_frames_eval() {
--- a/devtools/server/tests/unit/test_eval-05.js
+++ b/devtools/server/tests/unit/test_eval-05.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pauses_eval();
                            });
   });
   do_test_pending();
 }
 
 function test_pauses_eval() {
--- a/devtools/server/tests/unit/test_frameactor-01.js
+++ b/devtools/server/tests/unit/test_frameactor-01.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_frameactor-02.js
+++ b/devtools/server/tests/unit/test_frameactor-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_frameactor-03.js
+++ b/devtools/server/tests/unit/test_frameactor-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_frameactor-04.js
+++ b/devtools/server/tests/unit/test_frameactor-04.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 var gFrames = [
--- a/devtools/server/tests/unit/test_frameactor-05.js
+++ b/devtools/server/tests/unit/test_frameactor-05.js
@@ -14,17 +14,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_frameactor_wasm-01.js
+++ b/devtools/server/tests/unit/test_frameactor_wasm-01.js
@@ -19,17 +19,17 @@ function run_test() {
   }
 
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-stack",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         gThreadClient.reconfigure({
           observeAsmJS: true,
           wasmBinarySource: true
         }, function(response) {
           Assert.equal(!!response.error, false);
           test_pause_frame();
         });
--- a/devtools/server/tests/unit/test_framearguments-01.js
+++ b/devtools/server/tests/unit/test_framearguments-01.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-01.js
+++ b/devtools/server/tests/unit/test_framebindings-01.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-02.js
+++ b/devtools/server/tests/unit/test_framebindings-02.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-03.js
+++ b/devtools/server/tests/unit/test_framebindings-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-04.js
+++ b/devtools/server/tests/unit/test_framebindings-04.js
@@ -14,17 +14,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-05.js
+++ b/devtools/server/tests/unit/test_framebindings-05.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_framebindings-06.js
+++ b/devtools/server/tests/unit/test_framebindings-06.js
@@ -9,17 +9,17 @@ var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_banana_environment();
                            });
   });
   do_test_pending();
 }
 
 function test_banana_environment() {
--- a/devtools/server/tests/unit/test_framebindings-07.js
+++ b/devtools/server/tests/unit/test_framebindings-07.js
@@ -11,17 +11,17 @@ var gThreadClient;
 // Test that the EnvironmentClient's getBindings() method works as expected.
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-bindings");
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-bindings",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_banana_environment();
                            });
   });
   do_test_pending();
 }
 
 function test_banana_environment() {
--- a/devtools/server/tests/unit/test_frameclient-01.js
+++ b/devtools/server/tests/unit/test_frameclient-01.js
@@ -9,17 +9,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_frameclient-02.js
+++ b/devtools/server/tests/unit/test_frameclient-02.js
@@ -8,17 +8,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_functiongrips-01.js
+++ b/devtools/server/tests/unit/test_functiongrips-01.js
@@ -12,17 +12,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_named_function();
                            });
   });
   do_test_pending();
 }
 
 function test_named_function() {
--- a/devtools/server/tests/unit/test_get-executable-lines-source-map.js
+++ b/devtools/server/tests/unit/test_get-executable-lines-source-map.js
@@ -17,17 +17,17 @@ const SOURCE_MAPPED_FILE = getFileUrl("s
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-get-executable-lines");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function _onConnect() {
     attachTestTabAndResume(
       gClient,
       "test-get-executable-lines",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         test_executable_lines();
       }
     );
   });
 
   do_test_pending();
 }
--- a/devtools/server/tests/unit/test_get-executable-lines.js
+++ b/devtools/server/tests/unit/test_get-executable-lines.js
@@ -17,17 +17,17 @@ const SOURCE_MAPPED_FILE = getFileUrl("s
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-get-executable-lines");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function _onConnect() {
     attachTestTabAndResume(
       gClient,
       "test-get-executable-lines",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         test_executable_lines();
       }
     );
   });
 
   do_test_pending();
 }
--- a/devtools/server/tests/unit/test_interrupt.js
+++ b/devtools/server/tests/unit/test_interrupt.js
@@ -15,18 +15,18 @@ function run_test() {
   const transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(function(type, traits) {
     attachTestTab(gClient, "test-1", test_attach);
   });
   do_test_pending();
 }
 
-function test_attach(response, tabClient) {
-  tabClient.attachThread({}).then(function([response, threadClient]) {
+function test_attach(response, targetFront) {
+  targetFront.attachThread({}).then(function([response, threadClient]) {
     Assert.equal(threadClient.paused, true);
     threadClient.resume(function() {
       test_interrupt(threadClient);
     });
   });
 }
 
 function test_interrupt(threadClient) {
--- a/devtools/server/tests/unit/test_listsources-01.js
+++ b/devtools/server/tests/unit/test_listsources-01.js
@@ -22,17 +22,17 @@ function run_test() {
       if (request.type === "sources") {
         ++gNumTimesSourcesSent;
       }
       return origRequest.call(this, request, onResponse);
     };
   }(gClient.request));
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_listsources();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_listsources() {
--- a/devtools/server/tests/unit/test_listsources-02.js
+++ b/devtools/server/tests/unit/test_listsources-02.js
@@ -21,17 +21,17 @@ function run_test() {
       if (request.type === "sources") {
         ++gNumTimesSourcesSent;
       }
       return origRequest.call(this, request, onResponse);
     };
   }(gClient.request));
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_listing_zero_sources();
                            });
   });
   do_test_pending();
 }
 
 function test_listing_zero_sources() {
--- a/devtools/server/tests/unit/test_listsources-03.js
+++ b/devtools/server/tests/unit/test_listsources-03.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-sources");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-sources",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_listsources();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_listsources() {
--- a/devtools/server/tests/unit/test_longstringgrips-01.js
+++ b/devtools/server/tests/unit/test_longstringgrips-01.js
@@ -12,17 +12,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_longstring_grip();
                            });
   });
   do_test_pending();
 }
 
 function test_longstring_grip() {
--- a/devtools/server/tests/unit/test_longstringgrips-02.js
+++ b/devtools/server/tests/unit/test_longstringgrips-02.js
@@ -12,17 +12,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
-      gClient, "test-grips", function(response, tabClient, threadClient) {
+      gClient, "test-grips", function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         test_longstring_grip();
       });
   });
   do_test_pending();
 }
 
 function test_longstring_grip() {
--- a/devtools/server/tests/unit/test_nesting-01.js
+++ b/devtools/server/tests/unit/test_nesting-01.js
@@ -12,17 +12,17 @@ var gThreadActor;
 
 function run_test() {
   initTestDebuggerServer();
   addTestGlobal("test-nesting");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-nesting",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         // Reach over the protocol connection and get a reference to the thread actor.
         gThreadActor =
           threadClient._transport._serverConnection.getActor(threadClient._actor);
 
         test_nesting();
       });
   });
   do_test_pending();
--- a/devtools/server/tests/unit/test_nesting-02.js
+++ b/devtools/server/tests/unit/test_nesting-02.js
@@ -12,17 +12,17 @@ var gThreadActor;
 
 function run_test() {
   initTestDebuggerServer();
   addTestGlobal("test-nesting");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-nesting",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         // Reach over the protocol connection and get a reference to the thread
         // actor.
         gThreadActor =
           threadClient._transport._serverConnection.getActor(threadClient._actor);
 
         test_nesting();
       });
   });
--- a/devtools/server/tests/unit/test_nesting-03.js
+++ b/devtools/server/tests/unit/test_nesting-03.js
@@ -12,29 +12,29 @@ var gClient1, gClient2, gThreadClient1, 
 function run_test() {
   initTestDebuggerServer();
   addTestGlobal("test-nesting1");
   addTestGlobal("test-nesting1");
   // Conect the first client to the first debuggee.
   gClient1 = new DebuggerClient(DebuggerServer.connectPipe());
   gClient1.connect(function() {
     attachTestThread(gClient1, "test-nesting1",
-                     function(response, tabClient, threadClient) {
+                     function(response, targetFront, threadClient) {
                        gThreadClient1 = threadClient;
                        start_second_connection();
                      });
   });
   do_test_pending();
 }
 
 function start_second_connection() {
   gClient2 = new DebuggerClient(DebuggerServer.connectPipe());
   gClient2.connect(function() {
     attachTestThread(gClient2, "test-nesting1",
-                     function(response, tabClient, threadClient) {
+                     function(response, targetFront, threadClient) {
                        gThreadClient2 = threadClient;
                        test_nesting();
                      });
   });
 }
 
 function test_nesting() {
   gThreadClient1.resume(response => {
--- a/devtools/server/tests/unit/test_new_source-01.js
+++ b/devtools/server/tests/unit/test_new_source-01.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_new_source();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_new_source() {
--- a/devtools/server/tests/unit/test_new_source-02.js
+++ b/devtools/server/tests/unit/test_new_source-02.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_new_source();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_new_source() {
--- a/devtools/server/tests/unit/test_objectgrips-01.js
+++ b/devtools/server/tests/unit/test_objectgrips-01.js
@@ -21,17 +21,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-02.js
+++ b/devtools/server/tests/unit/test_objectgrips-02.js
@@ -22,17 +22,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-03.js
+++ b/devtools/server/tests/unit/test_objectgrips-03.js
@@ -22,17 +22,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-04.js
+++ b/devtools/server/tests/unit/test_objectgrips-04.js
@@ -22,17 +22,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-05.js
+++ b/devtools/server/tests/unit/test_objectgrips-05.js
@@ -26,17 +26,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1, arg2) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-06.js
+++ b/devtools/server/tests/unit/test_objectgrips-06.js
@@ -26,17 +26,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1, arg2) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-07.js
+++ b/devtools/server/tests/unit/test_objectgrips-07.js
@@ -26,17 +26,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1, arg2, arg3, arg4) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-08.js
+++ b/devtools/server/tests/unit/test_objectgrips-08.js
@@ -21,17 +21,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-09.js
+++ b/devtools/server/tests/unit/test_objectgrips-09.js
@@ -26,17 +26,17 @@ function run_test_with_server(server, ca
   gDebuggee = addTestGlobal("test-grips", server);
   gDebuggee.eval(function stopMe(arg1, arg2) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(server.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
 }
 
 function test_object_grip() {
   gThreadClient.addOneTimeListener("paused", function(event, packet) {
--- a/devtools/server/tests/unit/test_objectgrips-10.js
+++ b/devtools/server/tests/unit/test_objectgrips-10.js
@@ -12,17 +12,17 @@ var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-closures");
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-closures",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
   do_test_pending();
 }
 
 function test_object_grip() {
--- a/devtools/server/tests/unit/test_objectgrips-11.js
+++ b/devtools/server/tests/unit/test_objectgrips-11.js
@@ -14,17 +14,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_object_grip();
                            });
   });
   do_test_pending();
 }
 
 function test_object_grip() {
--- a/devtools/server/tests/unit/test_objectgrips-12.js
+++ b/devtools/server/tests/unit/test_objectgrips-12.js
@@ -17,17 +17,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   gDebuggee.eval(function stopMe(arg1) {
     debugger;
   }.toString());
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_display_string();
                            });
   });
   do_test_pending();
 }
 
 function test_display_string() {
--- a/devtools/server/tests/unit/test_objectgrips-13.js
+++ b/devtools/server/tests/unit/test_objectgrips-13.js
@@ -15,17 +15,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-grips");
   Cu.evalInSandbox(function stopMe() {
     debugger;
   }.toString(), gDebuggee);
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              add_pause_listener();
                            });
   });
   do_test_pending();
 }
 
 function add_pause_listener() {
--- a/devtools/server/tests/unit/test_objectgrips-14.js
+++ b/devtools/server/tests/unit/test_objectgrips-14.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-object-grip");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-object-grip",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testObjectGroup();
                            });
   });
   do_test_pending();
 }
 
 function evalCode() {
--- a/devtools/server/tests/unit/test_objectgrips-15.js
+++ b/devtools/server/tests/unit/test_objectgrips-15.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-object-grip");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-object-grip",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              testObjectGroup();
                            });
   });
   do_test_pending();
 }
 
 function evalCode() {
--- a/devtools/server/tests/unit/test_pause_exceptions-01.js
+++ b/devtools/server/tests/unit/test_pause_exceptions-01.js
@@ -14,17 +14,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_pause_exceptions-02.js
+++ b/devtools/server/tests/unit/test_pause_exceptions-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_pauselifetime-01.js
+++ b/devtools/server/tests/unit/test_pauselifetime-01.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_pauselifetime-02.js
+++ b/devtools/server/tests/unit/test_pauselifetime-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_pauselifetime-03.js
+++ b/devtools/server/tests/unit/test_pauselifetime-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_pauselifetime-04.js
+++ b/devtools/server/tests/unit/test_pauselifetime-04.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-stack");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-stack",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_pause_frame();
                            });
   });
   do_test_pending();
 }
 
 function test_pause_frame() {
--- a/devtools/server/tests/unit/test_promise_state-01.js
+++ b/devtools/server/tests/unit/test_promise_state-01.js
@@ -11,17 +11,17 @@
 
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function() {
     attachTestTabAndResume(
       client, "test-promise-state",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         (async function() {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "pending");
--- a/devtools/server/tests/unit/test_promise_state-02.js
+++ b/devtools/server/tests/unit/test_promise_state-02.js
@@ -11,17 +11,17 @@
 
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function() {
     attachTestTabAndResume(
       client, "test-promise-state",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         (async function() {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "fulfilled");
--- a/devtools/server/tests/unit/test_promise_state-03.js
+++ b/devtools/server/tests/unit/test_promise_state-03.js
@@ -11,17 +11,17 @@
 
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-promise-state");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   client.connect().then(function() {
     attachTestTabAndResume(
       client, "test-promise-state",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         (async function() {
           const packet = await executeOnNextTickAndWaitForPause(
             () => evalCode(debuggee), client);
 
           const grip = packet.frame.environment.bindings.variables.p;
           ok(grip.value.preview);
           equal(grip.value.class, "Promise");
           equal(grip.value.promiseState.state, "rejected");
--- a/devtools/server/tests/unit/test_reattach-thread.js
+++ b/devtools/server/tests/unit/test_reattach-thread.js
@@ -2,54 +2,54 @@
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 /**
  * Test that reattaching to a previously detached thread works.
  */
 
-var gClient, gDebuggee, gThreadClient, gTabClient;
+var gClient, gDebuggee, gThreadClient, gTargetFront;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = testGlobal("test-reattach");
   DebuggerServer.addTestGlobal(gDebuggee);
 
   const transport = DebuggerServer.connectPipe();
   gClient = new DebuggerClient(transport);
   gClient.connect().then(() => {
-    attachTestTab(gClient, "test-reattach", (reply, tabClient) => {
-      gTabClient = tabClient;
+    attachTestTab(gClient, "test-reattach", (reply, targetFront) => {
+      gTargetFront = targetFront;
       test_attach();
     });
   });
   do_test_pending();
 }
 
 function test_attach() {
-  gTabClient.attachThread({}).then(([response, threadClient]) => {
+  gTargetFront.attachThread({}).then(([response, threadClient]) => {
     Assert.equal(threadClient.state, "paused");
     gThreadClient = threadClient;
     threadClient.resume(test_detach);
   });
 }
 
 function test_detach() {
   gThreadClient.detach(() => {
     Assert.equal(gThreadClient.state, "detached");
-    Assert.equal(gTabClient.thread, null);
+    Assert.equal(gTargetFront.thread, null);
     test_reattach();
   });
 }
 
 function test_reattach() {
-  gTabClient.attachThread({}).then(([response, threadClient]) => {
+  gTargetFront.attachThread({}).then(([response, threadClient]) => {
     Assert.notEqual(gThreadClient, threadClient);
     Assert.equal(threadClient.state, "paused");
-    Assert.equal(gTabClient.thread, threadClient);
+    Assert.equal(gTargetFront.thread, threadClient);
     threadClient.resume(cleanup);
   });
 }
 
 function cleanup() {
   gClient.close().then(do_test_finished);
 }
--- a/devtools/server/tests/unit/test_setBreakpoint-at-the-beginning-of-a-line.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-at-the-beginning-of-a-line.js
@@ -10,18 +10,18 @@ async function run_test() {
   const global = createTestGlobal("test");
   DebuggerServer.addTestGlobal(global);
 
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(client);
 
   const { tabs } = await listTabs(client);
   const tab = findTab(tabs, "test");
-  const [, tabClient] = await attachTarget(client, tab);
-  const [, threadClient] = await attachThread(tabClient);
+  const [, targetFront] = await attachTarget(client, tab);
+  const [, threadClient] = await attachThread(targetFront);
   await resume(threadClient);
 
   const promise = waitForNewSource(threadClient, SOURCE_URL);
   loadSubScript(SOURCE_URL, global);
   const { source } = await promise;
   const sourceClient = threadClient.source(source);
 
   const location = { line: 4, column: 2 };
--- a/devtools/server/tests/unit/test_setBreakpoint-at-the-end-of-a-line.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-at-the-end-of-a-line.js
@@ -12,18 +12,18 @@ async function run_test() {
   const global = createTestGlobal("test");
   DebuggerServer.addTestGlobal(global);
 
   const client = new DebuggerClient(DebuggerServer.connectPipe());
   await connect(client);
 
   const { tabs } = await listTabs(client);
   const tab = findTab(tabs, "test");
-  const [, tabClient] = await attachTarget(client, tab);
-  const [, threadClient] = await attachThread(tabClient);
+  const [, targetFront] = await attachTarget(client, tab);
+  const [, threadClient] = await attachThread(targetFront);
   await resume(threadClient);
 
   const promise = waitForNewSource(threadClient, SOURCE_URL);
   loadSubScript(SOURCE_URL, global);
   const { source } = await promise;
   const sourceClient = threadClient.source(source);
 
   const location = { line: 4, column: 42 };
--- a/devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-column-in-gcd-script.js
@@ -14,31 +14,31 @@ function run_test() {
     DebuggerServer.setRootActor(createRootActor);
     DebuggerServer.init(() => true);
     DebuggerServer.addTestGlobal(global);
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
-    const [, threadClient] = await attachThread(tabClient);
+    const [, targetFront] = await attachTarget(client, tab);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const { sources } = await getSources(threadClient);
     const source = findSource(sources, SOURCE_URL);
     const sourceClient = threadClient.source(source);
 
     const location = { line: 6, column: 17 };
     let [packet, breakpointClient] = await setBreakpoint(sourceClient, location);
     Assert.ok(packet.isPending);
     Assert.equal(false, "actualLocation" in packet);
 
     packet = await executeOnNextTickAndWaitForPause(function() {
-      reload(tabClient).then(function() {
+      reload(targetFront).then(function() {
         loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
       });
     }, client);
     Assert.equal(packet.type, "paused");
     const why = packet.why;
     Assert.equal(why.type, "breakpoint");
     Assert.equal(why.actors.length, 1);
     Assert.equal(why.actors[0], breakpointClient.actor);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-column.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-column.js
@@ -13,18 +13,18 @@ function run_test() {
     const global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
-    const [, threadClient] = await attachThread(tabClient);
+    const [, targetFront] = await attachTarget(client, tab);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const promise = waitForNewSource(threadClient, SOURCE_URL);
     loadSubScript(SOURCE_URL, global);
     const { source } = await promise;
     const sourceClient = threadClient.source(source);
 
     const location = { line: 4, column: 17 };
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-in-gcd-script.js
@@ -14,31 +14,31 @@ function run_test() {
     DebuggerServer.setRootActor(createRootActor);
     DebuggerServer.init(() => true);
     DebuggerServer.addTestGlobal(global);
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
-    const [, threadClient] = await attachThread(tabClient);
+    const [, targetFront] = await attachTarget(client, tab);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const { sources } = await getSources(threadClient);
     const source = findSource(sources, SOURCE_URL);
     const sourceClient = threadClient.source(source);
 
     const location = { line: 7 };
     let [packet, breakpointClient] = await setBreakpoint(sourceClient, location);
     Assert.ok(packet.isPending);
     Assert.equal(false, "actualLocation" in packet);
 
     packet = await executeOnNextTickAndWaitForPause(function() {
-      reload(tabClient).then(function() {
+      reload(targetFront).then(function() {
         loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
       });
     }, client);
     Assert.equal(packet.type, "paused");
     const why = packet.why;
     Assert.equal(why.type, "breakpoint");
     Assert.equal(why.actors.length, 1);
     Assert.equal(why.actors[0], breakpointClient.actor);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-offsets.js
@@ -13,19 +13,19 @@ function run_test() {
     const global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
+    const [, targetFront] = await attachTarget(client, tab);
 
-    const [, threadClient] = await attachThread(tabClient);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const promise = waitForNewSource(threadClient, SOURCE_URL);
     loadSubScript(SOURCE_URL, global);
     const { source } = await promise;
     const sourceClient = threadClient.source(source);
 
     const location = { line: 4 };
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-multiple-statements.js
@@ -13,19 +13,19 @@ function run_test() {
     const global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
+    const [, targetFront] = await attachTarget(client, tab);
 
-    const [, threadClient] = await attachThread(tabClient);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const promise = waitForNewSource(threadClient, SOURCE_URL);
     loadSubScript(SOURCE_URL, global);
     const { source } = await promise;
     const sourceClient = threadClient.source(source);
 
     const location = { line: 4 };
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets-in-gcd-script.js
@@ -15,31 +15,31 @@ function run_test() {
     DebuggerServer.init(() => true);
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
-    const [, threadClient] = await attachThread(tabClient);
+    const [, targetFront] = await attachTarget(client, tab);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const { sources } = await getSources(threadClient);
     const source = findSource(sources, SOURCE_URL);
     const sourceClient = threadClient.source(source);
 
     const location = { line: 7 };
     let [packet, breakpointClient] = await setBreakpoint(sourceClient, location);
     Assert.ok(packet.isPending);
     Assert.equal(false, "actualLocation" in packet);
 
     packet = await executeOnNextTickAndWaitForPause(function() {
-      reload(tabClient).then(function() {
+      reload(targetFront).then(function() {
         loadSubScriptWithOptions(SOURCE_URL, {target: global, ignoreCache: true});
       });
     }, client);
     Assert.equal(packet.type, "paused");
     const why = packet.why;
     Assert.equal(why.type, "breakpoint");
     Assert.equal(why.actors.length, 1);
     Assert.equal(why.actors[0], breakpointClient.actor);
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line-with-no-offsets.js
@@ -13,18 +13,18 @@ function run_test() {
     const global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
-    const [, threadClient] = await attachThread(tabClient);
+    const [, targetFront] = await attachTarget(client, tab);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const promise = waitForNewSource(threadClient, SOURCE_URL);
     loadSubScript(SOURCE_URL, global);
     const { source } = await promise;
     const sourceClient = threadClient.source(source);
 
     const location = { line: 5 };
--- a/devtools/server/tests/unit/test_setBreakpoint-on-line.js
+++ b/devtools/server/tests/unit/test_setBreakpoint-on-line.js
@@ -13,19 +13,19 @@ function run_test() {
     const global = createTestGlobal("test");
     DebuggerServer.addTestGlobal(global);
 
     const client = new DebuggerClient(DebuggerServer.connectPipe());
     await connect(client);
 
     const { tabs } = await listTabs(client);
     const tab = findTab(tabs, "test");
-    const [, tabClient] = await attachTarget(client, tab);
+    const [, targetFront] = await attachTarget(client, tab);
 
-    const [, threadClient] = await attachThread(tabClient);
+    const [, threadClient] = await attachThread(targetFront);
     await resume(threadClient);
 
     const promise = waitForNewSource(threadClient, SOURCE_URL);
     loadSubScript(SOURCE_URL, global);
     const { source } = await promise;
     const sourceClient = threadClient.source(source);
 
     const location = { line: 5 };
--- a/devtools/server/tests/unit/test_source-01.js
+++ b/devtools/server/tests/unit/test_source-01.js
@@ -23,17 +23,17 @@ function run_test() {
     gDebuggee,
     "1.8",
     getFileUrl("test_source-01.js")
   );
 
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_source();
                            });
   });
   do_test_pending();
 }
 
 const SOURCE_URL = "http://example.com/foobar.js";
--- a/devtools/server/tests/unit/test_sourcemaps-01.js
+++ b/devtools/server/tests/unit/test_sourcemaps-01.js
@@ -14,17 +14,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_source_map();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_source_map() {
--- a/devtools/server/tests/unit/test_sourcemaps-02.js
+++ b/devtools/server/tests/unit/test_sourcemaps-02.js
@@ -14,17 +14,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_source_map();
                            });
   });
   do_test_pending();
 }
 
 function test_simple_source_map() {
--- a/devtools/server/tests/unit/test_sourcemaps-03.js
+++ b/devtools/server/tests/unit/test_sourcemaps-03.js
@@ -14,17 +14,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_simple_source_map();
                            });
   });
   do_test_pending();
 }
 
 function testBreakpointMapping(name, callback) {
--- a/devtools/server/tests/unit/test_sourcemaps-04.js
+++ b/devtools/server/tests/unit/test_sourcemaps-04.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_absolute_source_map();
                            });
   });
   do_test_pending();
 }
 
 function test_absolute_source_map() {
--- a/devtools/server/tests/unit/test_sourcemaps-05.js
+++ b/devtools/server/tests/unit/test_sourcemaps-05.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_relative_source_map();
                            });
   });
   do_test_pending();
 }
 
 function test_relative_source_map() {
--- a/devtools/server/tests/unit/test_sourcemaps-06.js
+++ b/devtools/server/tests/unit/test_sourcemaps-06.js
@@ -15,17 +15,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_source_content();
                            });
   });
   do_test_pending();
 }
 
 function test_source_content() {
--- a/devtools/server/tests/unit/test_sourcemaps-07.js
+++ b/devtools/server/tests/unit/test_sourcemaps-07.js
@@ -15,17 +15,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_cached_original_sources();
                            });
   });
   do_test_pending();
 }
 
 function test_cached_original_sources() {
--- a/devtools/server/tests/unit/test_sourcemaps-08.js
+++ b/devtools/server/tests/unit/test_sourcemaps-08.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_source_maps();
                            });
   });
   do_test_pending();
 }
 
 function test_source_maps() {
--- a/devtools/server/tests/unit/test_sourcemaps-09.js
+++ b/devtools/server/tests/unit/test_sourcemaps-09.js
@@ -12,17 +12,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_minified();
                            });
   });
   do_test_pending();
 }
 
 function test_minified() {
--- a/devtools/server/tests/unit/test_sourcemaps-10.js
+++ b/devtools/server/tests/unit/test_sourcemaps-10.js
@@ -15,17 +15,17 @@ const {SourceNode} = require("source-map
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-source-map",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         Promise.resolve(define_code())
           .then(run_code)
           .then(test_frame_location)
           .catch(error => {
             dump(error + "\n");
             dump(error.stack);
             Assert.ok(false);
--- a/devtools/server/tests/unit/test_sourcemaps-11.js
+++ b/devtools/server/tests/unit/test_sourcemaps-11.js
@@ -15,17 +15,17 @@ const {SourceNode} = require("source-map
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(
       gClient, "test-source-map",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         Promise.resolve(define_code())
           .then(run_code)
           .then(test_frames)
           .catch(error => {
             dump(error + "\n");
             dump(error.stack);
             Assert.ok(false);
--- a/devtools/server/tests/unit/test_sourcemaps-12.js
+++ b/devtools/server/tests/unit/test_sourcemaps-12.js
@@ -15,17 +15,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              define_code();
                            });
   });
   do_test_pending();
 }
 
 function define_code() {
--- a/devtools/server/tests/unit/test_sourcemaps-13.js
+++ b/devtools/server/tests/unit/test_sourcemaps-13.js
@@ -5,29 +5,29 @@
 
 /**
  * Test that we don't permanently cache source maps across reloads.
  */
 
 var gDebuggee;
 var gClient;
 var gThreadClient;
-var gTabClient;
+var gTargetFront;
 
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
-                             gTabClient = tabClient;
+                             gTargetFront = targetFront;
                              setup_code();
                            });
   });
   do_test_pending();
 }
 
 // The MAP_FILE_NAME is .txt so that the OS will definitely have an extension ->
 // content type mapping for the extension. If it doesn't (like .map or .json),
@@ -59,17 +59,17 @@ function setup_code() {
 }
 
 function test_initial_sources() {
   gThreadClient.getSources(function({ error, sources }) {
     Assert.ok(!error);
     sources = sources.filter(source => source.url);
     Assert.equal(sources.length, 1);
     Assert.equal(sources[0].url, getFileUrl(TEMP_FILE_1, true));
-    reload(gTabClient).then(setup_new_code);
+    reload(gTargetFront).then(setup_new_code);
   });
 }
 
 function setup_new_code() {
   const node = new SourceNode(1, 0,
                             getFileUrl(TEMP_FILE_2, true),
                             "function temporary2() {}\n");
   let { code, map } = node.toStringWithSourceMap({
--- a/devtools/server/tests/unit/test_sourcemaps-16.js
+++ b/devtools/server/tests/unit/test_sourcemaps-16.js
@@ -16,17 +16,17 @@ function run_test() {
   gDebuggee = addTestGlobal("test-sourcemaps");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestThread(gClient, "test-sourcemaps", testSourcemap);
   });
   do_test_pending();
 }
 
-const testSourcemap = async function(threadResponse, tabClient, threadClient,
+const testSourcemap = async function(threadResponse, targetFront, threadClient,
   tabResponse) {
   evalTestCode();
 
   const { sources } = await getSources(threadClient);
 
   for (const form of sources) {
     const sourceResponse = await getSourceContent(threadClient.source(form));
     ok(sourceResponse, "Should be able to get the source response");
--- a/devtools/server/tests/unit/test_sourcemaps-17.js
+++ b/devtools/server/tests/unit/test_sourcemaps-17.js
@@ -15,17 +15,17 @@ var gThreadClient;
 const {SourceNode} = require("source-map");
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-source-map");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-source-map",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_source_map();
                            });
   });
   do_test_pending();
 }
 
 function test_source_map() {
--- a/devtools/server/tests/unit/test_symbols-01.js
+++ b/devtools/server/tests/unit/test_symbols-01.js
@@ -11,17 +11,17 @@ const URL = "foo.js";
 
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-symbols");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
 
   client.connect().then(function() {
     attachTestTabAndResume(client, "test-symbols",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              add_task(testSymbols.bind(null, client, debuggee));
                              run_next_test();
                            });
   });
 
   do_test_pending();
 }
 
--- a/devtools/server/tests/unit/test_symbols-02.js
+++ b/devtools/server/tests/unit/test_symbols-02.js
@@ -11,17 +11,17 @@ const URL = "foo.js";
 
 function run_test() {
   initTestDebuggerServer();
   const debuggee = addTestGlobal("test-symbols");
   const client = new DebuggerClient(DebuggerServer.connectPipe());
 
   client.connect().then(function() {
     attachTestTabAndResume(client, "test-symbols",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              add_task(testSymbols.bind(null, client, debuggee));
                              run_next_test();
                            });
   });
 
   do_test_pending();
 }
 
--- a/devtools/server/tests/unit/test_threadlifetime-01.js
+++ b/devtools/server/tests/unit/test_threadlifetime-01.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function test_thread_lifetime() {
--- a/devtools/server/tests/unit/test_threadlifetime-02.js
+++ b/devtools/server/tests/unit/test_threadlifetime-02.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function test_thread_lifetime() {
--- a/devtools/server/tests/unit/test_threadlifetime-03.js
+++ b/devtools/server/tests/unit/test_threadlifetime-03.js
@@ -13,17 +13,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function test_thread_lifetime() {
--- a/devtools/server/tests/unit/test_threadlifetime-04.js
+++ b/devtools/server/tests/unit/test_threadlifetime-04.js
@@ -14,17 +14,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function test_thread_lifetime() {
--- a/devtools/server/tests/unit/test_threadlifetime-05.js
+++ b/devtools/server/tests/unit/test_threadlifetime-05.js
@@ -14,17 +14,17 @@ var gThreadClient;
 var gPauseGrip;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function arg_grips(frameArgs, onResponse) {
--- a/devtools/server/tests/unit/test_threadlifetime-06.js
+++ b/devtools/server/tests/unit/test_threadlifetime-06.js
@@ -14,17 +14,17 @@ var gClient;
 var gThreadClient;
 
 function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-grips");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     attachTestTabAndResume(gClient, "test-grips",
-                           function(response, tabClient, threadClient) {
+                           function(response, targetFront, threadClient) {
                              gThreadClient = threadClient;
                              test_thread_lifetime();
                            });
   });
   do_test_pending();
 }
 
 function test_thread_lifetime() {
--- a/devtools/server/tests/unit/test_wasm_source-01.js
+++ b/devtools/server/tests/unit/test_wasm_source-01.js
@@ -22,17 +22,17 @@ function run_test() {
   initTestDebuggerServer();
   gDebuggee = addTestGlobal("test-wasm-source");
   gClient = new DebuggerClient(DebuggerServer.connectPipe());
   gClient.connect().then(function() {
     Assert.ok(gClient.mainRoot.traits.wasmBinarySource);
 
     attachTestTabAndResume(
       gClient, "test-wasm-source",
-      function(response, tabClient, threadClient) {
+      function(response, targetFront, threadClient) {
         gThreadClient = threadClient;
         gThreadClient.reconfigure({
           observeAsmJS: true,
           wasmBinarySource: true
         }, function(response) {
           Assert.equal(!!response.error, false);
           test_source();
         });
--- a/devtools/shared/webconsole/test/common.js
+++ b/devtools/shared/webconsole/test/common.js
@@ -89,35 +89,35 @@ var _attachConsole = async function(
   response = await state.dbgClient.listTabs();
   if (response.error) {
     console.error("listTabs failed: " + response.error + " " +
                   response.message);
     callback(state, response);
     return;
   }
   const tab = response.tabs[response.selected];
-  const [, tabClient] = await state.dbgClient.attachTarget(tab.actor);
+  const [, targetFront] = await state.dbgClient.attachTarget(tab.actor);
   if (attachToWorker) {
     const workerName = "console-test-worker.js#" + new Date().getTime();
     const worker = new Worker(workerName);
     // Keep a strong reference to the Worker to avoid it being
     // GCd during the test (bug 1237492).
     // eslint-disable-next-line camelcase
     state._worker_ref = worker;
     await waitForMessage(worker);
 
-    const { workers } = await tabClient.listWorkers();
+    const { workers } = await targetFront.listWorkers();
     const workerTargetActor = workers.filter(w => w.url == workerName)[0].actor;
     if (!workerTargetActor) {
       console.error("listWorkers failed. Unable to find the " +
                     "worker actor\n");
       return;
     }
     const [workerResponse, workerClient] =
-      await tabClient.attachWorker(workerTargetActor);
+      await targetFront.attachWorker(workerTargetActor);
     if (!workerClient || workerResponse.error) {
       console.error("attachWorker failed. No worker client or " +
                     " error: " + workerResponse.error);
       return;
     }
     await workerClient.attachThread({});
     state.actor = workerClient.consoleActor;
     state.dbgClient.attachConsole(workerClient.consoleActor, listeners)