Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

36 files changed, 4670 insertions, 0 deletions

diff --git a/devtools/shared/webconsole/test/chrome/.eslintrc.js b/devtools/shared/webconsole/test/chrome/.eslintrc.js
new file mode 100644
index 0000000000..660a3bf0a9
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/.eslintrc.js
@@ -0,0 +1,6 @@
+"use strict";
+
+module.exports = {
+  // Extend from the shared list of defined globals for mochitests.
+  extends: "plugin:mozilla/chrome-test",
+};
diff --git a/devtools/shared/webconsole/test/chrome/chrome.ini b/devtools/shared/webconsole/test/chrome/chrome.ini
new file mode 100644
index 0000000000..e38c97a81b
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/chrome.ini
@@ -0,0 +1,40 @@
+[DEFAULT]
+tags = devtools
+support-files =
+  common.js
+  data.json
+  data.json^headers^
+  helper_serviceworker.js
+  network_requests_iframe.html
+  sandboxed_iframe.html
+  console-test-worker.js
+  !/browser/base/content/test/general/browser_star_hsts.sjs
+
+[test_basics.html]
+[test_bug819670_getter_throws.html]
+[test_cached_messages.html]
+[test_commands_other.html]
+[test_consoleapi.html]
+[test_consoleapi_innerID.html]
+[test_console_assert.html]
+[test_console_group_styling.html]
+[test_console_serviceworker.html]
+[test_console_serviceworker_cached.html]
+[test_console_styling.html]
+[test_console_timestamp.html]
+[test_console_worker.html]
+[test_file_uri.html]
+[test_jsterm.html]
+[test_jsterm_autocomplete.html]
+[test_jsterm_last_result.html]
+[test_jsterm_queryselector.html]
+[test_network_get.html]
+skip-if = verify
+[test_network_post.html]
+[test_network_security-hsts.html]
+[test_nsiconsolemessage.html]
+[test_object_actor.html]
+[test_object_actor_native_getters.html]
+[test_object_actor_native_getters_lenient_this.html]
+[test_page_errors.html]
+[test_throw.html]
diff --git a/devtools/shared/webconsole/test/chrome/common.js b/devtools/shared/webconsole/test/chrome/common.js
new file mode 100644
index 0000000000..810ac0eed6
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/common.js
@@ -0,0 +1,281 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/* exported attachConsole, attachConsoleToTab, attachConsoleToWorker,
+   closeDebugger, checkConsoleAPICalls, checkRawHeaders, runTests, nextTest, Ci, Cc,
+   withActiveServiceWorker, Services, consoleAPICall */
+
+const { require } = ChromeUtils.import("resource://devtools/shared/Loader.jsm");
+const { DevToolsServer } = require("devtools/server/devtools-server");
+// eslint-disable-next-line mozilla/reject-some-requires
+const { DevToolsClient } = require("devtools/client/devtools-client");
+
+const Services = require("Services");
+
+function initCommon() {
+  // Services.prefs.setBoolPref("devtools.debugger.log", true);
+}
+
+function initDevToolsServer() {
+  DevToolsServer.init();
+  DevToolsServer.registerAllActors();
+  DevToolsServer.allowChromeProcess = true;
+}
+
+async function connectToDebugger() {
+  initCommon();
+  initDevToolsServer();
+
+  const transport = DevToolsServer.connectPipe();
+  const client = new DevToolsClient(transport);
+
+  await client.connect();
+  return client;
+}
+
+function attachConsole(listeners) {
+  return _attachConsole(listeners);
+}
+function attachConsoleToTab(listeners) {
+  return _attachConsole(listeners, true);
+}
+function attachConsoleToWorker(listeners) {
+  return _attachConsole(listeners, true, true);
+}
+
+var _attachConsole = async function(listeners, attachToTab, attachToWorker) {
+  try {
+    const client = await connectToDebugger();
+
+    function waitForMessage(target) {
+      return new Promise(resolve => {
+        target.addEventListener("message", resolve, { once: true });
+      });
+    }
+
+    // Fetch the console actor out of the expected target
+    // ParentProcessTarget / WorkerTarget / FrameTarget
+    let target, worker;
+    if (!attachToTab) {
+      const targetDescriptor = await client.mainRoot.getMainProcess();
+      target = await targetDescriptor.getTarget();
+    } else {
+      const targetDescriptor = await client.mainRoot.getTab();
+      target = await targetDescriptor.getTarget();
+      if (attachToWorker) {
+        const workerName = "console-test-worker.js#" + new Date().getTime();
+        worker = new Worker(workerName);
+        await waitForMessage(worker);
+
+        // listWorkers only works if the browsing context target actor is attached
+        await target.attach();
+        const { workers } = await target.listWorkers();
+        target = workers.filter(w => w.url == workerName)[0];
+        if (!target) {
+          console.error(
+            "listWorkers failed. Unable to find the worker actor\n"
+          );
+          return null;
+        }
+      }
+    }
+
+    // Attach the Target and the target thread in order to instantiate the console client.
+    await target.attach();
+    await target.attachThread();
+
+    const webConsoleFront = await target.getFront("console");
+
+    // By default the console isn't listening for anything,
+    // request listeners from here
+    const response = await webConsoleFront.startListeners(listeners);
+    return {
+      state: {
+        dbgClient: client,
+        webConsoleFront,
+        actor: webConsoleFront.actor,
+        // Keep a strong reference to the Worker to avoid it being
+        // GCd during the test (bug 1237492).
+        // eslint-disable-next-line camelcase
+        _worker_ref: worker,
+      },
+      response,
+    };
+  } catch (error) {
+    console.error(
+      `attachConsole failed: ${error.error} ${error.message} - ` + error.stack
+    );
+  }
+  return null;
+};
+
+function closeDebugger(state, callback) {
+  const onClose = state.dbgClient.close();
+
+  state.dbgClient = null;
+  state.client = null;
+
+  if (typeof callback === "function") {
+    onClose.then(callback);
+  }
+  return onClose;
+}
+
+function checkConsoleAPICalls(consoleCalls, expectedConsoleCalls) {
+  is(
+    consoleCalls.length,
+    expectedConsoleCalls.length,
+    "received correct number of console calls"
+  );
+  expectedConsoleCalls.forEach(function(message, index) {
+    info("checking received console call #" + index);
+    checkConsoleAPICall(consoleCalls[index], expectedConsoleCalls[index]);
+  });
+}
+
+function checkConsoleAPICall(call, expected) {
+  is(
+    call.arguments?.length || 0,
+    expected.arguments?.length || 0,
+    "number of arguments"
+  );
+
+  checkObject(call, expected);
+}
+
+function checkObject(object, expected) {
+  if (object && object.getGrip) {
+    object = object.getGrip();
+  }
+
+  for (const name of Object.keys(expected)) {
+    const expectedValue = expected[name];
+    const value = object[name];
+    checkValue(name, value, expectedValue);
+  }
+}
+
+function checkValue(name, value, expected) {
+  if (expected === null) {
+    ok(!value, "'" + name + "' is null");
+  } else if (value === undefined) {
+    ok(false, "'" + name + "' is undefined");
+  } else if (value === null) {
+    ok(false, "'" + name + "' is null");
+  } else if (
+    typeof expected == "string" ||
+    typeof expected == "number" ||
+    typeof expected == "boolean"
+  ) {
+    is(value, expected, "property '" + name + "'");
+  } else if (expected instanceof RegExp) {
+    ok(expected.test(value), name + ": " + expected + " matched " + value);
+  } else if (Array.isArray(expected)) {
+    info("checking array for property '" + name + "'");
+    checkObject(value, expected);
+  } else if (typeof expected == "object") {
+    info("checking object for property '" + name + "'");
+    checkObject(value, expected);
+  }
+}
+
+function checkHeadersOrCookies(array, expected) {
+  const foundHeaders = {};
+
+  for (const elem of array) {
+    if (!(elem.name in expected)) {
+      continue;
+    }
+    foundHeaders[elem.name] = true;
+    info("checking value of header " + elem.name);
+    checkValue(elem.name, elem.value, expected[elem.name]);
+  }
+
+  for (const header in expected) {
+    if (!(header in foundHeaders)) {
+      ok(false, header + " was not found");
+    }
+  }
+}
+
+function checkRawHeaders(text, expected) {
+  const headers = text.split(/\r\n|\n|\r/);
+  const arr = [];
+  for (const header of headers) {
+    const index = header.indexOf(": ");
+    if (index < 0) {
+      continue;
+    }
+    arr.push({
+      name: header.substr(0, index),
+      value: header.substr(index + 2),
+    });
+  }
+
+  checkHeadersOrCookies(arr, expected);
+}
+
+var gTestState = {};
+
+function runTests(tests, endCallback) {
+  function* driver() {
+    let lastResult, sendToNext;
+    for (let i = 0; i < tests.length; i++) {
+      gTestState.index = i;
+      const fn = tests[i];
+      info("will run test #" + i + ": " + fn.name);
+      lastResult = fn(sendToNext, lastResult);
+      sendToNext = yield lastResult;
+    }
+    yield endCallback(sendToNext, lastResult);
+  }
+  gTestState.driver = driver();
+  return gTestState.driver.next();
+}
+
+function nextTest(message) {
+  return gTestState.driver.next(message);
+}
+
+function withActiveServiceWorker(win, url, scope) {
+  const opts = {};
+  if (scope) {
+    opts.scope = scope;
+  }
+  return win.navigator.serviceWorker.register(url, opts).then(swr => {
+    if (swr.active) {
+      return swr;
+    }
+
+    // Unfortunately we can't just use navigator.serviceWorker.ready promise
+    // here.  If the service worker is for a scope that does not cover the window
+    // then the ready promise will never resolve.  Instead monitor the service
+    // workers state change events to determine when its activated.
+    return new Promise(resolve => {
+      const sw = swr.waiting || swr.installing;
+      sw.addEventListener("statechange", function stateHandler(evt) {
+        if (sw.state === "activated") {
+          sw.removeEventListener("statechange", stateHandler);
+          resolve(swr);
+        }
+      });
+    });
+  });
+}
+
+/**
+ *
+ * @param {Front} consoleFront
+ * @param {Function} consoleCall: A function which calls the consoleAPI, e.g. :
+ *                         `() => top.console.log("test")`.
+ * @returns {Promise} A promise that will be resolved with the packet sent by the server
+ *                    in response to the consoleAPI call.
+ */
+function consoleAPICall(consoleFront, consoleCall) {
+  const onConsoleAPICall = consoleFront.once("consoleAPICall");
+  consoleCall();
+  return onConsoleAPICall;
+}
diff --git a/devtools/shared/webconsole/test/chrome/console-test-worker.js b/devtools/shared/webconsole/test/chrome/console-test-worker.js
new file mode 100644
index 0000000000..b3091faf8f
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/console-test-worker.js
@@ -0,0 +1,19 @@
+"use strict";
+
+console.log("Log from worker init");
+
+function f() {
+  const a = 1;
+  const b = 2;
+  const c = 3;
+  return { a, b, c };
+}
+
+self.onmessage = function(event) {
+  if (event.data == "ping") {
+    f();
+    postMessage("pong");
+  }
+};
+
+postMessage("load");
diff --git a/devtools/shared/webconsole/test/chrome/data.json b/devtools/shared/webconsole/test/chrome/data.json
new file mode 100644
index 0000000000..d46085c124
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/data.json
@@ -0,0 +1,3 @@
+{ id: "test JSON data", myArray: [ "foo", "bar", "baz", "biff" ],
+  veryLong: "foo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo barfoo bar"
+}
diff --git a/devtools/shared/webconsole/test/chrome/data.json^headers^ b/devtools/shared/webconsole/test/chrome/data.json^headers^
new file mode 100644
index 0000000000..bb6b45500f
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/data.json^headers^
@@ -0,0 +1,3 @@
+Content-Type: application/json
+x-very-long: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse a ipsum massa. Phasellus at elit dictum libero laoreet sagittis. Phasellus condimentum ultricies imperdiet. Nam eu ligula justo, ut tincidunt quam. Etiam sollicitudin, tortor sed egestas blandit, sapien sem tincidunt nulla, eu luctus libero odio quis leo. Nam elit massa, mattis quis blandit ac, facilisis vitae arcu. Donec vitae dictum neque. Proin ornare nisl at lectus commodo iaculis eget eget est. Quisque scelerisque vestibulum quam sed interdum.
+x-very-short: hello world
diff --git a/devtools/shared/webconsole/test/chrome/helper_serviceworker.js b/devtools/shared/webconsole/test/chrome/helper_serviceworker.js
new file mode 100644
index 0000000000..5f0f520819
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/helper_serviceworker.js
@@ -0,0 +1,21 @@
+"use strict";
+
+console.log("script evaluation");
+
+addEventListener("install", function(evt) {
+  console.log("install event");
+});
+
+addEventListener("activate", function(evt) {
+  console.log("activate event");
+});
+
+addEventListener("fetch", function(evt) {
+  console.log("fetch event: " + evt.request.url);
+  evt.respondWith(new Response("Hello world"));
+});
+
+addEventListener("message", function(evt) {
+  console.log("message event: " + evt.data.message);
+  evt.source.postMessage({ type: "PONG" });
+});
diff --git a/devtools/shared/webconsole/test/chrome/network_requests_iframe.html b/devtools/shared/webconsole/test/chrome/network_requests_iframe.html
new file mode 100644
index 0000000000..c380941a1e
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/network_requests_iframe.html
@@ -0,0 +1,66 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Console HTTP test page</title>
+    <!-- Any copyright is dedicated to the Public Domain.
+       - http://creativecommons.org/publicdomain/zero/1.0/ -->
+    <script type="text/javascript"><!--
+      "use strict";
+      let setAllowAllCookies = false;
+
+      function makeXhr(method, url, requestBody, callback) {
+        // On the first call, allow all cookies and set cookies, then resume the actual test
+        if (!setAllowAllCookies) {
+          SpecialPowers.pushPrefEnv({"set": [["network.cookie.cookieBehavior", 0]]},
+          function() {
+            setAllowAllCookies = true;
+            setCookies();
+            makeXhrCallback(method, url, requestBody, callback);
+          });
+        } else {
+          makeXhrCallback(method, url, requestBody, callback);
+        }
+      }
+
+      function makeXhrCallback(method, url, requestBody, callback) {
+        const xmlhttp = new XMLHttpRequest();
+        xmlhttp.open(method, url, true);
+        if (callback) {
+          xmlhttp.onreadystatechange = function() {
+            if (xmlhttp.readyState == 4) {
+              callback();
+            }
+          };
+        }
+        xmlhttp.send(requestBody);
+      }
+
+      /* exported testXhrGet */
+      function testXhrGet(callback) {
+        makeXhr("get", "data.json", null, callback);
+      }
+
+      /* exported testXhrPost */
+      function testXhrPost(callback) {
+        const body = "Hello world! " + (new Array(50)).join("foobaz barr");
+        makeXhr("post", "data.json", body, callback);
+      }
+
+      function setCookies() {
+        document.cookie = "foobar=fooval";
+        document.cookie = "omgfoo=bug768096";
+        document.cookie = "badcookie=bug826798=st3fan";
+      }
+      </script>
+  </head>
+  <body>
+    <h1>Web Console HTTP Logging Testpage</h1>
+    <h2>This page is used to test the HTTP logging.</h2>
+
+    <form action="?" method="post">
+      <input name="name" type="text" value="foo bar"><br>
+      <input name="age" type="text" value="144"><br>
+    </form>
+  </body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html b/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html
new file mode 100644
index 0000000000..55a6224b50
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html
@@ -0,0 +1,8 @@
+<html>
+<head><title>Sandboxed iframe</title></head>
+<body>
+  <iframe id="sandboxed-iframe"
+          sandbox="allow-scripts"
+          srcdoc="<script>var foobarObject = {bug1051224: 'sandboxed'};</script>"></iframe>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_basics.html b/devtools/shared/webconsole/test/chrome/test_basics.html
new file mode 100644
index 0000000000..97ca75e775
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_basics.html
@@ -0,0 +1,64 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Basic Web Console Actor tests</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Basic Web Console Actor tests</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  let {state, response} = await attachConsoleToTab(["PageError"]);
+  is(response.startedListeners.length, 1, "startedListeners.length");
+  is(response.startedListeners[0], "PageError", "startedListeners: PageError");
+  ok(response.nativeConsoleAPI, "nativeConsoleAPI");
+
+  await closeDebugger(state);
+  top.console_ = top.console;
+  top.console = { lolz: "foo" };
+  ({state, response} = await attachConsoleToTab(["PageError", "ConsoleAPI", "foo"]));
+
+  const startedListeners = response.startedListeners;
+  is(startedListeners.length, 2, "startedListeners.length");
+  isnot(startedListeners.indexOf("PageError"), -1, "startedListeners: PageError");
+  isnot(startedListeners.indexOf("ConsoleAPI"), -1,
+        "startedListeners: ConsoleAPI");
+  is(startedListeners.indexOf("foo"), -1, "startedListeners: no foo");
+  ok(!response.nativeConsoleAPI, "!nativeConsoleAPI");
+
+  top.console = top.console_;
+  response = await state.webConsoleFront.stopListeners(["ConsoleAPI", "foo"]);
+
+  is(response.stoppedListeners.length, 1, "stoppedListeners.length");
+  is(response.stoppedListeners[0], "ConsoleAPI", "stoppedListeners: ConsoleAPI");
+  await closeDebugger(state);
+  ({state, response} = await attachConsoleToTab(["ConsoleAPI"]));
+
+  is(response.startedListeners.length, 1, "startedListeners.length");
+  is(response.startedListeners[0], "ConsoleAPI", "startedListeners: ConsoleAPI");
+  ok(response.nativeConsoleAPI, "nativeConsoleAPI");
+
+  top.console = top.console_;
+  delete top.console_;
+
+  closeDebugger(state, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_bug819670_getter_throws.html b/devtools/shared/webconsole/test/chrome/test_bug819670_getter_throws.html
new file mode 100644
index 0000000000..aa34705eb5
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_bug819670_getter_throws.html
@@ -0,0 +1,52 @@
+<!DOCTYPE HTML>
+<html lang="en">
+  <head>
+    <meta charset="utf8">
+    <title>Test for Bug 819670 - Web console object inspection does not handle native getters throwing very well</title>
+    <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+    <script type="text/javascript" src="common.js"></script>
+    <!-- Any copyright is dedicated to the Public Domain.
+         - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  </head>
+  <body>
+    <p>Test for Bug 819670 - Web console object inspection does not handle native getters throwing very well</p>
+
+    <script class="testbody" type="text/javascript">
+      "use strict";
+
+      SimpleTest.waitForExplicitFinish();
+      addEventListener("load", startTest);
+
+      async function startTest() {
+        removeEventListener("load", startTest);
+        const {state} = await attachConsoleToTab([]);
+        const evaluationResponse = await state.webConsoleFront.evaluateJSAsync("document.__proto__");
+        checkObject(evaluationResponse, {
+          input: "document.__proto__",
+          result: {
+            type: "object",
+            actor: /[a-z]/
+          }
+        });
+
+        ok(!evaluationResponse.exception, "no eval exception");
+        ok(!evaluationResponse.helperResult, "no helper result");
+
+        const response = await evaluationResponse.result.getPrototypeAndProperties();
+        ok(! response.error, "no response error");
+
+        const props = response.ownProperties;
+        ok(props, "response properties available");
+
+        if (props) {
+          // eslint-disable-next-line no-proto
+          const expectedProps = Object.getOwnPropertyNames(document.__proto__);
+          isDeeply(Object.keys(props), expectedProps, "Same own properties.");
+        }
+
+        await closeDebugger(state);
+        SimpleTest.finish();
+      }
+    </script>
+  </body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_cached_messages.html b/devtools/shared/webconsole/test/chrome/test_cached_messages.html
new file mode 100644
index 0000000000..45ff466d78
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_cached_messages.html
@@ -0,0 +1,221 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for cached messages</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for cached messages</p>
+
+<script class="testbody" type="application/javascript">
+"use strict";
+
+const { MESSAGE_CATEGORY } = require("devtools/shared/constants");
+
+const previousEnabled = window.docShell.cssErrorReportingEnabled;
+window.docShell.cssErrorReportingEnabled = true;
+
+SimpleTest.registerCleanupFunction(() => {
+  window.docShell.cssErrorReportingEnabled = previousEnabled;
+});
+
+var ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"]
+                          .getService(Ci.nsIConsoleAPIStorage);
+let expectedConsoleCalls = [];
+let expectedPageErrors = [];
+
+function doPageErrors() {
+  Services.console.reset();
+
+  expectedPageErrors = [
+    {
+      errorMessage: /fooColor/,
+      sourceName: /.+/,
+      category: MESSAGE_CATEGORY.CSS_PARSER,
+      timeStamp: /^\d+$/,
+      error: false,
+      warning: true,
+    },
+    {
+      errorMessage: /doTheImpossible/,
+      sourceName: /.+/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+  ];
+
+  let container = document.createElement("script");
+  document.body.appendChild(container);
+  container.textContent = "document.body.style.color = 'fooColor';";
+  document.body.removeChild(container);
+
+  SimpleTest.expectUncaughtException();
+
+  container = document.createElement("script");
+  document.body.appendChild(container);
+  container.textContent = "document.doTheImpossible();";
+  document.body.removeChild(container);
+}
+
+function doConsoleCalls() {
+  ConsoleAPIStorage.clearEvents();
+
+  top.console.log("foobarBaz-log", undefined);
+  top.console.info("foobarBaz-info", null);
+  top.console.warn("foobarBaz-warn", document.body);
+
+  expectedConsoleCalls = [
+    {
+      level: "log",
+      filename: /test_cached_messages/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-log", { type: "undefined" }],
+    },
+    {
+      level: "info",
+      filename: /test_cached_messages/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-info", { type: "null" }],
+    },
+    {
+      level: "warn",
+      filename: /test_cached_messages/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }],
+    },
+  ];
+}
+</script>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+var {ConsoleServiceListener} =
+  require("devtools/server/actors/webconsole/listeners/console-service");
+var {ConsoleAPIListener} =
+  require("devtools/server/actors/webconsole/listeners/console-api");
+
+let consoleAPIListener, consoleServiceListener;
+let consoleAPICalls = 0;
+let pageErrors = 0;
+
+async function onConsoleAPICall(message) {
+  for (const msg of expectedConsoleCalls) {
+    if (msg.functionName == message.functionName &&
+        msg.filename.test(message.filename)) {
+      consoleAPICalls++;
+      break;
+    }
+  }
+  if (consoleAPICalls == expectedConsoleCalls.length) {
+    await checkConsoleAPICache();
+  }
+}
+
+async function onConsoleServiceMessage(message) {
+  if (!(message instanceof Ci.nsIScriptError)) {
+    return;
+  }
+  for (const msg of expectedPageErrors) {
+    if (msg.category == message.category &&
+        msg.errorMessage.test(message.errorMessage)) {
+      pageErrors++;
+      break;
+    }
+  }
+  if (pageErrors == expectedPageErrors.length) {
+    await testPageErrors();
+  }
+}
+
+function startTest() {
+  removeEventListener("load", startTest);
+
+  consoleAPIListener = new ConsoleAPIListener(top, onConsoleAPICall);
+  consoleAPIListener.init();
+
+  doConsoleCalls();
+}
+
+async function checkConsoleAPICache() {
+  consoleAPIListener.destroy();
+  consoleAPIListener = null;
+  const {state} = await attachConsole(["ConsoleAPI"]);
+  const response = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]);
+  onCachedConsoleAPI(state, response);
+}
+
+function onCachedConsoleAPI(state, response) {
+  const msgs = response.messages;
+  info("cached console messages: " + msgs.length);
+
+  ok(msgs.length >= expectedConsoleCalls.length,
+     "number of cached console messages");
+
+  for (const {message} of msgs) {
+    for (const expected of expectedConsoleCalls) {
+      if (expected.functionName == message.functionName &&
+          expected.filename.test(message.filename)) {
+        expectedConsoleCalls.splice(expectedConsoleCalls.indexOf(expected));
+        checkConsoleAPICall(message, expected);
+        break;
+      }
+    }
+  }
+
+  is(expectedConsoleCalls.length, 0, "all expected messages have been found");
+
+  closeDebugger(state, function() {
+    consoleServiceListener = new ConsoleServiceListener(null, onConsoleServiceMessage);
+    consoleServiceListener.init();
+    doPageErrors();
+  });
+}
+
+async function testPageErrors() {
+  consoleServiceListener.destroy();
+  consoleServiceListener = null;
+  const {state} = await attachConsole(["PageError"]);
+  const response = await state.webConsoleFront.getCachedMessages(["PageError"]);
+  onCachedPageErrors(state, response);
+}
+
+function onCachedPageErrors(state, response) {
+  const msgs = response.messages;
+  info("cached page errors: " + msgs.length);
+
+  ok(msgs.length >= expectedPageErrors.length,
+     "number of cached page errors");
+
+  for (const {pageError} of msgs) {
+    for (const expected of expectedPageErrors) {
+      if (expected.category == pageError.category &&
+          expected.errorMessage.test(pageError.errorMessage)) {
+        expectedPageErrors.splice(expectedPageErrors.indexOf(expected));
+        checkObject(pageError, expected);
+        break;
+      }
+    }
+  }
+
+  is(expectedPageErrors.length, 0, "all expected messages have been found");
+
+  closeDebugger(state, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_commands_other.html b/devtools/shared/webconsole/test/chrome/test_commands_other.html
new file mode 100644
index 0000000000..702d01f354
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_commands_other.html
@@ -0,0 +1,84 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the other command helpers</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the querySelector / querySelectorAll helpers</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+let gState;
+let gWin;
+const tests = [
+  async function keys() {
+    const response = await evaluateJS("keys({foo: 'bar'})");
+    checkObject(response, {
+      result: {
+        class: "Array",
+        preview: {
+          items: ["foo"]
+        }
+      }
+    });
+    nextTest();
+  },
+  async function values() {
+    const response = await evaluateJS("values({foo: 'bar'})");
+    checkObject(response, {
+      result: {
+        class: "Array",
+        preview: {
+          items: ["bar"]
+        }
+      }
+    });
+    nextTest();
+  },
+];
+
+function evaluateJS(input) {
+  return gState.webConsoleFront.evaluateJSAsync(input);
+}
+
+async function startTest() {
+  info ("Content window opened, attaching console to it");
+
+  const systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
+  ok (!gWin.document.nodePrincipal.equals(systemPrincipal),
+      "The test document is not using the system principal");
+
+  const {state} = await attachConsoleToTab([]);
+  gState = state;
+  runTests(tests, testEnd);
+}
+
+function testEnd() {
+  gWin.close();
+  gWin = null;
+  closeDebugger(gState, function() {
+    gState = null;
+    SimpleTest.finish();
+  });
+}
+
+const load = async function () {
+  removeEventListener("load", load);
+
+  // Open a content window to test XRay functionality on built in functions.
+  gWin = window.open("javascript:'<html><body>dummy</body></html>';");
+  info ("Waiting for content window to load");
+  gWin.onload = startTest;
+};
+addEventListener("load", load);
+
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_assert.html b/devtools/shared/webconsole/test/chrome/test_console_assert.html
new file mode 100644
index 0000000000..f847d5f5d8
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_assert.html
@@ -0,0 +1,106 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for console.group styling with %c</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <script>
+"use strict";
+
+window.onload = async function () {
+  SimpleTest.waitForExplicitFinish();
+  let state;
+  try {
+    state = (await attachConsole(["ConsoleAPI"])).state;
+    const {webConsoleFront} = state;
+
+    await testFalseAssert(webConsoleFront);
+    await testFalsyAssert(webConsoleFront);
+    await testUndefinedAssert(webConsoleFront);
+    await testNullAssert(webConsoleFront);
+    await testTrueAssert(webConsoleFront);
+
+  } catch (e) {
+    ok(false, `Error thrown: ${e.message}`);
+  }
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+};
+
+async function testFalseAssert(consoleFront) {
+  info(`Testing console.assert(false)`);
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.assert(false, "assertion is false")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["assertion is false"]
+  });
+}
+
+async function testFalsyAssert(consoleFront) {
+  info(`Testing console.assert(0")`);
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.assert(0, "assertion is false")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["assertion is false"]
+  });
+}
+
+async function testUndefinedAssert(consoleFront) {
+  info(`Testing console.assert(undefined)`);
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.assert(undefined, "assertion is false")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["assertion is false"]
+  });
+}
+
+async function testNullAssert(consoleFront) {
+  info(`Testing console.assert(null)`);
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.assert(null, "assertion is false")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["assertion is false"]
+  });
+}
+
+async function testTrueAssert(consoleFront) {
+  info(`Testing console.assert(true)`);
+  const onConsoleApiCall = consoleAPICall(
+    consoleFront,
+    () => top.console.assert(true, "assertion is false")
+  );
+
+  const TIMEOUT = Symbol();
+  const onTimeout = new Promise(resolve => setTimeout(() => resolve(TIMEOUT), 1000));
+
+  const res = await Promise.race([onConsoleApiCall, onTimeout]);
+  is(res, TIMEOUT,
+    "There was no consoleAPICall event in response to a truthy console.assert");
+}
+
+  </script>
+</head>
+<body>
+  <p id="display"></p>
+  <div id="content" style="display: none">
+  </div>
+  <pre id="test">
+  </pre>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_group_styling.html b/devtools/shared/webconsole/test/chrome/test_console_group_styling.html
new file mode 100644
index 0000000000..62ad760614
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_group_styling.html
@@ -0,0 +1,121 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for console.group styling with %c</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <script>
+"use strict";
+
+window.onload = async function () {
+  SimpleTest.waitForExplicitFinish();
+  let state;
+  try {
+    state = (await attachConsole(["ConsoleAPI"])).state
+    const consoleFront = state.webConsoleFront;
+
+    await testSingleCustomStyleGroup(consoleFront);
+    await testSingleCustomStyleGroupCollapsed(consoleFront);
+    await testMultipleCustomStyleGroup(consoleFront);
+    await testMultipleCustomStyleGroupCollapsed(consoleFront);
+    await testFormatterWithNoStyleGroup(consoleFront);
+    await testFormatterWithNoStyleGroupCollapsed(consoleFront);
+  } catch (e) {
+    ok(false, `Error thrown: ${e.message}`);
+  }
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+};
+
+async function testSingleCustomStyleGroup(consoleFront) {
+  info("Testing console.group with a custom style");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.group("%cfoobar", "color:red")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["foobar"],
+    styles: ["color:red"]
+  });
+}
+
+async function testSingleCustomStyleGroupCollapsed(consoleFront) {
+  info("Testing console.groupCollapsed with a custom style");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.groupCollapsed("%cfoobaz", "color:blue")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["foobaz"],
+    styles: ["color:blue"]
+  });
+}
+
+async function testMultipleCustomStyleGroup(consoleFront) {
+  info("Testing console.group with multiple custom styles");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.group("%cfoo%cbar", "color:red", "color:blue")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["foo", "bar"],
+    styles: ["color:red", "color:blue"]
+  });
+}
+
+async function testMultipleCustomStyleGroupCollapsed(consoleFront) {
+  info("Testing console.groupCollapsed with multiple custom styles");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.group("%cfoo%cbaz", "color:red", "color:green")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["foo", "baz"],
+    styles: ["color:red", "color:green"]
+  });
+}
+
+async function testFormatterWithNoStyleGroup(consoleFront) {
+  info("Testing console.group with one formatter but no style");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.group("%cfoobar")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["%cfoobar"],
+    styles: []
+  });
+}
+
+async function testFormatterWithNoStyleGroupCollapsed(consoleFront) {
+  info("Testing console.groupCollapsed with one formatter but no style");
+  const packet = await consoleAPICall(
+    consoleFront,
+    () => top.console.groupCollapsed("%cfoobaz")
+  );
+
+  checkConsoleAPICall(packet.message, {
+    arguments: ["%cfoobaz"],
+    styles: []
+  });
+}
+
+  </script>
+</head>
+<body>
+  <p id="display"></p>
+  <div id="content" style="display: none">
+  </div>
+  <pre id="test">
+  </pre>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html b/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html
new file mode 100644
index 0000000000..79d1e2e3a2
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_serviceworker.html
@@ -0,0 +1,202 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the Console API and Service Workers</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the Console API and Service Workers</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+// Utils functions
+function withFrame(url) {
+  return new Promise(resolve => {
+    const iframe = document.createElement("iframe");
+    iframe.onload = function () {
+      resolve(iframe);
+    };
+    iframe.src = url;
+    document.body.appendChild(iframe);
+  });
+}
+
+function navigateFrame(iframe, url) {
+  return new Promise(resolve => {
+    iframe.onload = function () {
+      resolve(iframe);
+    };
+    iframe.src = url;
+  });
+}
+
+function forceReloadFrame(iframe) {
+  return new Promise(resolve => {
+    iframe.onload = function () {
+      resolve(iframe);
+    };
+    iframe.contentWindow.location.reload(true);
+  });
+}
+
+function messageServiceWorker(win, scope, message) {
+  return win.navigator.serviceWorker.getRegistration(scope).then(swr => {
+    return new Promise(resolve => {
+      win.navigator.serviceWorker.onmessage = evt => {
+        resolve();
+      };
+      const sw = swr.active || swr.waiting || swr.installing;
+      sw.postMessage({ type: "PING", message: message });
+    });
+  });
+}
+
+function unregisterServiceWorker(win) {
+  return win.navigator.serviceWorker.ready.then(swr => {
+    return swr.unregister();
+  });
+}
+
+// Test
+const BASE_URL = "https://example.com/chrome/devtools/shared/webconsole/test/chrome/";
+const SERVICE_WORKER_URL = BASE_URL + "helper_serviceworker.js";
+const SCOPE = BASE_URL + "foo/";
+const NONSCOPE_FRAME_URL = BASE_URL + "sandboxed_iframe.html";
+const SCOPE_FRAME_URL = SCOPE + "fake.html";
+const SCOPE_FRAME_URL2 = SCOPE + "whatsit.html";
+const MESSAGE = 'Tic Tock';
+
+const expectedConsoleCalls = [
+    {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['script evaluation'],
+    },
+    {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['install event'],
+    },
+    {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['activate event'],
+    },
+    {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['fetch event: ' + SCOPE_FRAME_URL],
+    },
+    {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['fetch event: ' + SCOPE_FRAME_URL2],
+    },
+];
+let consoleCalls = [];
+
+const startTest = async function () {
+  removeEventListener("load", startTest);
+
+  await new Promise(resolve => {
+    SpecialPowers.pushPrefEnv({"set": [
+      ["dom.serviceWorkers.enabled", true],
+      ["devtools.webconsole.filter.serviceworkers", true]
+    ]}, resolve);
+  });
+
+  const {state, response} = await attachConsoleToTab(["ConsoleAPI"]);
+  onAttach(state, response);
+};
+addEventListener("load", startTest);
+
+const onAttach = async function (state, response) {
+  onConsoleAPICall = onConsoleAPICall.bind(null, state);
+  state.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
+
+  let currentFrame;
+  try {
+    // First, we need a frame from which to register our script.  This
+    // will not trigger any console calls.
+    info("Loading a non-scope frame from which to register a service worker.");
+    currentFrame = await withFrame(NONSCOPE_FRAME_URL);
+
+    // Now register the service worker and wait for it to become
+    // activate.  This should trigger 3 console calls; 1 for script
+    // evaluation, 1 for the install event, and 1 for the activate
+    // event.  These console calls are received because we called
+    // register(), not because we are in scope for the worker.
+    info("Registering the service worker");
+    await withActiveServiceWorker(currentFrame.contentWindow,
+                                  SERVICE_WORKER_URL, SCOPE);
+    ok(!currentFrame.contentWindow.navigator.serviceWorker.controller,
+       'current frame should not be controlled');
+
+    // Now that the service worker is activate, lets navigate our frame.
+    // This will trigger 1 more console call for the fetch event.
+    info("Service worker registered. Navigating frame.");
+    await navigateFrame(currentFrame, SCOPE_FRAME_URL);
+    ok(currentFrame.contentWindow.navigator.serviceWorker.controller,
+       'navigated frame should be controlled');
+
+    // We now have a controlled frame.  Lets perform a non-navigation fetch.
+    // This should produce another console call for the fetch event.
+    info("Frame navigated.  Calling fetch().");
+    await currentFrame.contentWindow.fetch(SCOPE_FRAME_URL2);
+
+    // Now force refresh our controlled frame.  This will cause the frame
+    // to bypass the service worker and become an uncontrolled frame.  It
+    // also happens to make the frame display a 404 message because the URL
+    // does not resolve to a real resource.  This is ok, as we really only
+    // care about the frame being non-controlled, but still having a location
+    // that matches our service worker scope so we can provide its not
+    // incorrectly getting console calls.
+    info("Completed fetch().  Force refreshing to get uncontrolled frame.");
+    await forceReloadFrame(currentFrame);
+    ok(!currentFrame.contentWindow.navigator.serviceWorker.controller,
+       'current frame should not be controlled after force refresh');
+    is(currentFrame.contentWindow.location.toString(), SCOPE_FRAME_URL,
+       'current frame should still have in-scope location URL even though it got 404');
+
+    // Now postMessage() the service worker to trigger its message event
+    // handler.  This will generate 1 or 2 to console.log() statements
+    // depending on if the worker thread needs to spin up again.  In either
+    // case, though, we should not get any console calls because we don't
+    // have a controlled or registering document.
+    info("Completed force refresh.  Messaging service worker.");
+    await messageServiceWorker(currentFrame.contentWindow, SCOPE, MESSAGE);
+
+    info("Done messaging service worker.  Unregistering service worker.");
+    await unregisterServiceWorker(currentFrame.contentWindow);
+
+    info('Service worker unregistered.  Checking console calls.');
+    state.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
+    checkConsoleAPICalls(consoleCalls, expectedConsoleCalls);
+  } catch(error) {
+    ok(false, 'unexpected error: ' + error);
+  } finally {
+    if (currentFrame) {
+      currentFrame.remove();
+      currentFrame = null;
+    }
+    consoleCalls = [];
+    closeDebugger(state, function() {
+      SimpleTest.finish();
+    });
+  }
+};
+
+function onConsoleAPICall(state, packet) {
+  info("received message level: " + packet.message.level);
+  consoleCalls.push(packet.message);
+}
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html b/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html
new file mode 100644
index 0000000000..9f94f82f93
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_serviceworker_cached.html
@@ -0,0 +1,119 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for getCachedMessages and Service Workers</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for getCachedMessages and Service Workers</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+const BASE_URL = "https://example.com/chrome/devtools/shared/webconsole/test/chrome/";
+const SERVICE_WORKER_URL = BASE_URL + "helper_serviceworker.js";
+const FRAME_URL = BASE_URL + "sandboxed_iframe.html";
+
+const firstTabExpectedCalls = [
+  {
+    message: {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['script evaluation'],
+    }
+  }, {
+    message: {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['install event'],
+    }
+  }, {
+    message: {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['activate event'],
+    }
+  },
+];
+
+const secondTabExpectedCalls = [
+  {
+    message: {
+      level: "log",
+      filename: /helper_serviceworker/,
+      arguments: ['fetch event: ' + FRAME_URL],
+    }
+  }
+];
+
+const startTest = async function () {
+  removeEventListener("load", startTest);
+
+  await new Promise(resolve => {
+    SpecialPowers.pushPrefEnv({"set": [
+      ["dom.serviceWorkers.enabled", true],
+      ["devtools.webconsole.filter.serviceworkers", true]
+    ]}, resolve);
+  });
+
+  info("Adding a tab and attaching a service worker");
+  const tab1 = await addTab(FRAME_URL);
+  const swr = await withActiveServiceWorker(tab1.linkedBrowser.contentWindow,
+                                SERVICE_WORKER_URL);
+
+  info("Attaching console to tab 1");
+  let {state} = await attachConsoleToTab(["ConsoleAPI"]);
+  let calls = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]);
+  checkConsoleAPICalls(calls.messages, firstTabExpectedCalls);
+  await closeDebugger(state);
+
+  // Because this tab is being added after the original messages happened,
+  // they shouldn't show up in a call to getCachedMessages.
+  // However, there is a fetch event which is logged due to loading the tab.
+  info("Adding a new tab at the same URL");
+
+  await addTab(FRAME_URL);
+  info("Attaching console to tab 2");
+  state = (await attachConsoleToTab(["ConsoleAPI"])).state;
+  calls = await state.webConsoleFront.getCachedMessages(["ConsoleAPI"]);
+  checkConsoleAPICalls(calls.messages, secondTabExpectedCalls);
+  await closeDebugger(state);
+
+  await swr.unregister();
+
+  SimpleTest.finish();
+};
+addEventListener("load", startTest);
+
+// This test needs to add tabs that are controlled by a service worker
+// so use some special powers to dig around and find gBrowser
+const {gBrowser} = SpecialPowers._getTopChromeWindow(SpecialPowers.window);
+
+SimpleTest.registerCleanupFunction(() => {
+  while (gBrowser.tabs.length > 1) {
+    gBrowser.removeCurrentTab();
+  }
+});
+
+function addTab(url) {
+  info("Adding a new tab with URL: '" + url + "'");
+  return new Promise(resolve => {
+    const tab = gBrowser.selectedTab = gBrowser.addTab(url, {
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+    });
+    gBrowser.selectedBrowser.addEventListener("load", function () {
+      info("URL '" + url + "' loading complete");
+      resolve(tab);
+    }, {capture: true, once: true});
+  });
+}
+
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_styling.html b/devtools/shared/webconsole/test/chrome/test_console_styling.html
new file mode 100644
index 0000000000..4a501dd22e
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_styling.html
@@ -0,0 +1,128 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for console.log styling with %c</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for console.log styling with %c</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+let expectedConsoleCalls = [];
+
+function doConsoleCalls(aState)
+{
+  top.console.log("%cOne formatter with no styles");
+  top.console.log("%cOne formatter", "color: red");
+  top.console.log("%cTwo formatters%cEach with an arg",
+    "color: red", "background: red");
+  top.console.log("%c%cTwo formatters next to each other",
+    "color: red", "background: red");
+  top.console.log("%c%c%cThree formatters next to each other",
+    "color: red", "background: red", "font-size: 150%");
+  top.console.log("%c%cTwo formatters%cWith a third separated",
+    "color: red", "background: red", "font-size: 150%");
+  top.console.log("%cOne formatter", "color: red",
+                  "Second arg with no styles");
+  top.console.log("%cOne formatter", "color: red",
+                  "%cSecond formatter is ignored", "background: blue")
+
+  expectedConsoleCalls = [
+    {
+      level: "log",
+      styles: /^$/,
+      arguments: ["%cOne formatter with no styles"],
+    },
+    {
+      level: "log",
+      styles: /^color: red$/,
+      arguments: ["One formatter"],
+    },
+    {
+      level: "log",
+      styles: /^color: red,background: red$/,
+      arguments: ["Two formatters", "Each with an arg"],
+    },
+    {
+      level: "log",
+      styles: /^background: red$/,
+      arguments: ["Two formatters next to each other"],
+    },
+    {
+      level: "log",
+      styles: /^font-size: 150%$/,
+      arguments: ["Three formatters next to each other"],
+    },
+    {
+      level: "log",
+      styles: /^background: red,font-size: 150%$/,
+      arguments: ["Two formatters", "With a third separated"],
+    },
+    {
+      level: "log",
+      styles: /^color: red$/,
+      arguments: ["One formatter", "Second arg with no styles"],
+    },
+    {
+      level: "log",
+      styles: /^color: red$/,
+      arguments: ["One formatter",
+                  "%cSecond formatter is ignored",
+                  "background: blue"],
+    },
+  ];
+}
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state, response} = await attachConsoleToTab(["ConsoleAPI"]);
+  onAttach(state, response);
+}
+
+function onAttach(aState, aResponse)
+{
+  onConsoleAPICall = onConsoleAPICall.bind(null, aState);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
+  doConsoleCalls(aState.actor);
+}
+
+let consoleCalls = [];
+
+function onConsoleAPICall(aState, aPacket)
+{
+  info("received message level: " + aPacket.message.level);
+
+  consoleCalls.push(aPacket.message);
+  if (consoleCalls.length != expectedConsoleCalls.length) {
+    return;
+  }
+
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
+
+  expectedConsoleCalls.forEach(function(aMessage, aIndex) {
+    info("checking received console call #" + aIndex);
+    checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
+  });
+
+
+  consoleCalls = [];
+
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_timestamp.html b/devtools/shared/webconsole/test/chrome/test_console_timestamp.html
new file mode 100644
index 0000000000..a64de0d7b2
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_timestamp.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for console.group styling with %c</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <script>
+"use strict";
+
+window.onload = async function () {
+  SimpleTest.waitForExplicitFinish();
+  let state;
+  try {
+    state = (await attachConsole(["ConsoleAPI"])).state;
+    const consoleFront = state.webConsoleFront;
+
+    info("Testing console.log packet timestamp correctness");
+    const clientLogTimestamp = Date.now();
+    const packet = await consoleAPICall(consoleFront,
+      () => top.console.log("test"));
+    const packetReceivedTimestamp = Date.now();
+
+    const {timeStamp} = packet.message;
+    ok(clientLogTimestamp <= timeStamp && timeStamp <= packetReceivedTimestamp,
+      "console.log message timestamp is between the expected time range " +
+      `(${clientLogTimestamp} <= ${timeStamp} <= ${packetReceivedTimestamp})`
+    );
+  } catch (e) {
+    ok(false, `Error thrown: ${e.message}`);
+  }
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+};
+
+  </script>
+</head>
+<body>
+  <p id="display"></p>
+  <div id="content" style="display: none">
+  </div>
+  <pre id="test">
+  </pre>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_console_worker.html b/devtools/shared/webconsole/test/chrome/test_console_worker.html
new file mode 100644
index 0000000000..fe89d3dbed
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_console_worker.html
@@ -0,0 +1,79 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the Console API and Workers</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the Console API and Workers</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+const expectedCachedConsoleCalls = [{
+  message:{
+    level: "log",
+    filename: /console-test-worker/,
+    arguments: ['Log from worker init'],
+  }
+}];
+
+const expectedConsoleAPICalls = [{
+  message: {
+    level: "log",
+    arguments: ['Log was requested from worker'],
+  }
+}];
+
+window.onload = async function () {
+  const {state} = await attachConsoleToWorker(["ConsoleAPI"]);
+
+  await testCachedMessages(state);
+  await testConsoleAPI(state);
+
+  closeDebugger(state, function() {
+    SimpleTest.finish();
+  });
+};
+
+const testCachedMessages = async function (state) {
+  info("testCachedMessages entered");
+  return new Promise(resolve => {
+    const onCachedConsoleAPI = (response) => {
+      const consoleCalls = response.messages;
+
+      info('Received cached response. Checking console calls.');
+      checkConsoleAPICalls(consoleCalls, expectedCachedConsoleCalls);
+      resolve();
+    };
+    state.webConsoleFront.getCachedMessages(["ConsoleAPI"]).then(onCachedConsoleAPI);
+  })
+};
+
+const testConsoleAPI = async function (state) {
+  info("testConsoleAPI entered");
+  return new Promise(resolve => {
+    const onConsoleAPICall = (packet) => {
+      info("received message level: " + packet.message.level);
+      checkConsoleAPICalls([packet], expectedConsoleAPICalls);
+      state.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
+      resolve();
+    }
+
+    info("testConsoleAPI: adding listener for consoleAPICall");
+    state.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
+
+    state.webConsoleFront.evaluateJSAsync("console.log('Log was requested from worker')",
+      () => { });
+  });
+};
+
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_consoleapi.html b/devtools/shared/webconsole/test/chrome/test_consoleapi.html
new file mode 100644
index 0000000000..7030728de4
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_consoleapi.html
@@ -0,0 +1,234 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the Console API</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the Console API</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+let expectedConsoleCalls = [];
+
+function doConsoleCalls(aState)
+{
+  const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 2)).join("a");
+
+  top.console.log("foobarBaz-log", undefined);
+
+  top.console.log("Float from not a number: %f", "foo");
+  top.console.log("Float from string: %f", "1.2");
+  top.console.log("Float from number: %f", 1.3);
+
+  top.console.info("foobarBaz-info", null);
+  top.console.warn("foobarBaz-warn", top.document.documentElement);
+  top.console.debug(null);
+  top.console.trace();
+  top.console.dir(top.document, top.location);
+  top.console.log("foo", longString);
+
+  const sandbox = new Cu.Sandbox(null, { invisibleToDebugger: true });
+  const sandboxObj = sandbox.eval("new Object");
+  top.console.log(sandboxObj);
+
+  function fromAsmJS() {
+      top.console.error("foobarBaz-asmjs-error", undefined);
+  }
+
+  (function(global, foreign) {
+    "use asm";
+    function inAsmJS2() { foreign.fromAsmJS() }
+    function inAsmJS1() { inAsmJS2() }
+    return inAsmJS1
+  })(null, { fromAsmJS:fromAsmJS })();
+
+  expectedConsoleCalls = [
+    {
+      level: "log",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-log", { type: "undefined" }],
+    },
+    {
+      level: "log",
+      arguments: ["Float from not a number: NaN"],
+    },
+    {
+      level: "log",
+      arguments: ["Float from string: 1.200000"],
+    },
+    {
+      level: "log",
+      arguments: ["Float from number: 1.300000"],
+    },
+    {
+      level: "info",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-info", { type: "null" }],
+    },
+    {
+      level: "warn",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }],
+    },
+    {
+      level: "debug",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [{ type: "null" }],
+    },
+    {
+      level: "trace",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      stacktrace: [
+        {
+          filename: /test_consoleapi/,
+          functionName: "doConsoleCalls",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "onAttach",
+        },
+      ],
+    },
+    {
+      level: "dir",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [
+        {
+          type: "object",
+          actor: /[a-z]/,
+          class: "HTMLDocument",
+        },
+        {
+          type: "object",
+          actor: /[a-z]/,
+          class: "Location",
+        }
+      ],
+    },
+    {
+      level: "log",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [
+        "foo",
+        {
+          type: "longString",
+          initial: longString.substring(0,
+            DevToolsServer.LONG_STRING_INITIAL_LENGTH),
+          length: longString.length,
+          actor: /[a-z]/,
+        },
+      ],
+    },
+    {
+      level: "log",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [
+        {
+          type: "object",
+          actor: /[a-z]/,
+          class: "InvisibleToDebugger: Object",
+        },
+      ],
+    },
+    {
+      level: "error",
+      filename: /test_consoleapi/,
+      functionName: "fromAsmJS",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-asmjs-error", { type: "undefined" }],
+
+      stacktrace: [
+        {
+          filename: /test_consoleapi/,
+          functionName: "fromAsmJS",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "inAsmJS2",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "inAsmJS1",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "doConsoleCalls",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "onAttach",
+        },
+      ],
+    },
+  ];
+}
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state, response} = await attachConsoleToTab(["ConsoleAPI"]);
+  onAttach(state, response);
+}
+
+function onAttach(aState, aResponse)
+{
+  onConsoleAPICall = onConsoleAPICall.bind(null, aState);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
+  doConsoleCalls(aState.actor);
+}
+
+let consoleCalls = [];
+
+function onConsoleAPICall(aState, aPacket)
+{
+  info("received message level: " + aPacket.message.level);
+
+  consoleCalls.push(aPacket.message);
+  if (consoleCalls.length != expectedConsoleCalls.length) {
+    return;
+  }
+
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
+
+  expectedConsoleCalls.forEach(function(aMessage, aIndex) {
+    info("checking received console call #" + aIndex);
+    checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
+  });
+
+
+  consoleCalls = [];
+
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html b/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html
new file mode 100644
index 0000000000..19b92e1d0d
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_consoleapi_innerID.html
@@ -0,0 +1,164 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the innerID property of the Console API</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the Console API</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+let expectedConsoleCalls = [];
+
+function doConsoleCalls(aState)
+{
+  const { ConsoleAPI } = ChromeUtils.import("resource://gre/modules/Console.jsm");
+  const console = new ConsoleAPI({
+    innerID: window.windowGlobalChild.innerWindowId
+  });
+
+  const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 2)).join("a");
+
+  console.log("foobarBaz-log", undefined);
+  console.info("foobarBaz-info", null);
+  console.warn("foobarBaz-warn", top.document.documentElement);
+  console.debug(null);
+  console.trace();
+  console.dir(top.document, top.location);
+  console.log("foo", longString);
+
+  expectedConsoleCalls = [
+    {
+      level: "log",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-log", { type: "undefined" }],
+    },
+    {
+      level: "info",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-info", { type: "null" }],
+    },
+    {
+      level: "warn",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: ["foobarBaz-warn", { type: "object", actor: /[a-z]/ }],
+    },
+    {
+      level: "debug",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [{ type: "null" }],
+    },
+    {
+      level: "trace",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      stacktrace: [
+        {
+          filename: /test_consoleapi/,
+          functionName: "doConsoleCalls",
+        },
+        {
+          filename: /test_consoleapi/,
+          functionName: "onAttach",
+        },
+      ],
+    },
+    {
+      level: "dir",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [
+        {
+          type: "object",
+          actor: /[a-z]/,
+          class: "HTMLDocument",
+        },
+        {
+          type: "object",
+          actor: /[a-z]/,
+          class: "Location",
+        }
+      ],
+    },
+    {
+      level: "log",
+      filename: /test_consoleapi/,
+      functionName: "doConsoleCalls",
+      timeStamp: /^\d+$/,
+      arguments: [
+        "foo",
+        {
+          type: "longString",
+          initial: longString.substring(0,
+            DevToolsServer.LONG_STRING_INITIAL_LENGTH),
+          length: longString.length,
+          actor: /[a-z]/,
+        },
+      ],
+    },
+  ];
+}
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state} = await attachConsoleToTab(["ConsoleAPI"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  onConsoleAPICall = onConsoleAPICall.bind(null, aState);
+  aState.webConsoleFront.on("consoleAPICall", onConsoleAPICall);
+  doConsoleCalls(aState.actor);
+}
+
+let consoleCalls = [];
+
+function onConsoleAPICall(aState, aPacket)
+{
+  info("received message level: " + aPacket.message.level);
+
+  consoleCalls.push(aPacket.message);
+  if (consoleCalls.length != expectedConsoleCalls.length) {
+    return;
+  }
+
+  aState.webConsoleFront.off("consoleAPICall", onConsoleAPICall);
+
+  expectedConsoleCalls.forEach(function(aMessage, aIndex) {
+    info("checking received console call #" + aIndex);
+    checkConsoleAPICall(consoleCalls[aIndex], expectedConsoleCalls[aIndex]);
+  });
+
+
+  consoleCalls = [];
+
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_file_uri.html b/devtools/shared/webconsole/test/chrome/test_file_uri.html
new file mode 100644
index 0000000000..23eb45b9fe
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_file_uri.html
@@ -0,0 +1,110 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for file activity tracking</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for file activity tracking</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+const {NetUtil} = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+const {FileUtils} = ChromeUtils.import("resource://gre/modules/FileUtils.jsm");
+
+let gState;
+let gTmpFile;
+
+function doFileActivity()
+{
+  info("doFileActivity");
+  const fileContent = "<p>hello world from bug 798764";
+
+  gTmpFile = FileUtils.getFile("TmpD", ["bug798764.html"]);
+  gTmpFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
+
+  const fout = FileUtils.openSafeFileOutputStream(gTmpFile,
+    FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE | FileUtils.MODE_TRUNCATE);
+
+  const converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+                  createInstance(Ci.nsIScriptableUnicodeConverter);
+  converter.charset = "UTF-8";
+  const fileContentStream = converter.convertToInputStream(fileContent);
+
+  NetUtil.asyncCopy(fileContentStream, fout, addIframe);
+}
+
+function addIframe(aStatus)
+{
+  ok(Components.isSuccessCode(aStatus),
+     "the temporary file was saved successfully");
+
+  const iframe = document.createElement("iframe");
+  iframe.src = NetUtil.newURI(gTmpFile).spec;
+  document.body.appendChild(iframe);
+}
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state} = await attachConsole(["FileActivity"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  gState = aState;
+  gState.webConsoleFront.on("fileActivity", onFileActivity);
+  doFileActivity();
+}
+
+function onFileActivity(aPacket)
+{
+  gState.webConsoleFront.off("fileActivity", onFileActivity);
+
+  info("aPacket.uri: " + aPacket.uri);
+  ok(/\bbug798764\b.*\.html$/.test(aPacket.uri), "file URI match");
+
+  testEnd();
+}
+
+function testEnd()
+{
+  if (gTmpFile) {
+    SimpleTest.executeSoon(function() {
+      try {
+        gTmpFile.remove(false);
+      }
+      catch (ex) {
+        if (ex.name != "NS_ERROR_FILE_IS_LOCKED") {
+          throw ex;
+        }
+        // Sometimes remove() throws because the file is not unlocked soon
+        // enough.
+      }
+      gTmpFile = null;
+    });
+  }
+
+  if (gState) {
+    closeDebugger(gState, function() {
+      gState = null;
+      SimpleTest.finish();
+    });
+  } else {
+    SimpleTest.finish();
+  }
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_jsterm.html b/devtools/shared/webconsole/test/chrome/test_jsterm.html
new file mode 100644
index 0000000000..65e7b519d8
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_jsterm.html
@@ -0,0 +1,273 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for JavaScript terminal functionality</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for JavaScript terminal functionality</p>
+
+<iframe id="content-iframe" src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html"></iframe>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+let gState;
+
+const {MAX_AUTOCOMPLETE_ATTEMPTS,MAX_AUTOCOMPLETIONS} = require("devtools/shared/webconsole/js-property-provider");
+
+
+function evaluateJS(input, options = {}) {
+  return gState.webConsoleFront.evaluateJSAsync(input, options);
+} 
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state} = await attachConsoleToTab(["PageError"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  top.foobarObject = Object.create(null);
+  top.foobarObject.foo = 1;
+  top.foobarObject.foobar = 2;
+  top.foobarObject.foobaz = 3;
+  top.foobarObject.omg = 4;
+  top.foobarObject.omgfoo = 5;
+  top.foobarObject.strfoo = "foobarz";
+  top.foobarObject.omgstr = "foobarz" +
+    (new Array(DevToolsServer.LONG_STRING_LENGTH * 2)).join("abb");
+
+  top.largeObject1 = Object.create(null);
+  for (let i = 0; i < MAX_AUTOCOMPLETE_ATTEMPTS + 1; i++) {
+    top.largeObject1['a' + i] = i;
+  }
+
+  top.largeObject2 = Object.create(null);
+  for (let i = 0; i < MAX_AUTOCOMPLETIONS * 2; i++) {
+    top.largeObject2['a' + i] = i;
+  }
+
+  gState = aState;
+
+  const tests = [doSimpleEval, doWindowEval, doEvalWithException,
+               doEvalWithHelper, doEvalString, doEvalLongString,
+               doEvalWithBinding, doEvalWithBindingFrame,
+               forceLexicalInit];
+
+  runTests(tests, testEnd);
+}
+
+async function doSimpleEval() {
+  info("test eval '2+2'");
+  const response = await evaluateJS("2+2");
+  checkObject(response, {
+    input: "2+2",
+    result: 4,
+  });
+
+  ok(!response.exception, "no eval exception");
+  ok(!response.helperResult, "no helper result");
+
+  nextTest();
+}
+
+async function doWindowEval() {
+  info("test eval 'document'");
+  const response = await evaluateJS("document");
+  checkObject(response, {
+    input: "document",
+    result: {
+      type: "object",
+      class: "HTMLDocument",
+      actor: /[a-z]/,
+    },
+  });
+
+  ok(!response.exception, "no eval exception");
+  ok(!response.helperResult, "no helper result");
+
+  nextTest();
+}
+
+async function doEvalWithException() {
+  info("test eval with exception");
+  const response = await evaluateJS("window.doTheImpossible()");
+  checkObject(response, {
+    input: "window.doTheImpossible()",
+    result: {
+      type: "undefined",
+    },
+    exceptionMessage: /doTheImpossible/,
+  });
+
+  ok(response.exception, "js eval exception");
+  ok(!response.helperResult, "no helper result");
+
+  nextTest();
+}
+
+async function doEvalWithHelper() {
+  info("test eval with helper");
+  const response = await evaluateJS("clear()");
+  checkObject(response, {
+    input: "clear()",
+    result: {
+      type: "undefined",
+    },
+    helperResult: { type: "clearOutput" },
+  });
+
+  ok(!response.exception, "no eval exception");
+
+  nextTest();
+}
+
+async function doEvalString() {
+  const response = await evaluateJS("window.foobarObject.strfoo");
+  checkObject(response, {
+    input: "window.foobarObject.strfoo",
+    result: "foobarz",
+  });
+
+  nextTest();
+}
+
+async function doEvalLongString() {
+  const response = await evaluateJS("window.foobarObject.omgstr");
+  const str = top.foobarObject.omgstr;
+  const initial = str.substring(0, DevToolsServer.LONG_STRING_INITIAL_LENGTH);
+
+  checkObject(response, {
+    input: "window.foobarObject.omgstr",
+    result: {
+      type: "longString",
+      initial: initial,
+      length: str.length,
+    },
+  });
+
+  nextTest();
+}
+
+async function doEvalWithBinding() {
+  const response = await evaluateJS("document;");
+  const documentActor = response.result.actorID;
+
+  info("running a command with _self as document using selectedObjectActor");
+  const selectedObjectSame = await evaluateJS("_self === document", {
+    selectedObjectActor: documentActor
+  });
+  checkObject(selectedObjectSame, {
+    result: true
+  });
+
+  nextTest();
+}
+
+async function doEvalWithBindingFrame() {
+  const frameWin = top.document.querySelector("iframe").contentWindow;
+  frameWin.fooFrame = { bar: 1 };
+
+  const response = await evaluateJS(
+    "document.querySelector('iframe').contentWindow.fooFrame"
+  );
+  const iframeObjectActor = response.result.actorID;
+  ok(iframeObjectActor, "There is an actor associated with the response");
+
+  await evaluateJS("this.temp1 = _self;", {
+    selectedObjectActor: iframeObjectActor
+  });
+  ok(top.temp1 && top.temp1.bar === 1,
+    "Global matches the top global with bindObjectActor");
+  ok(!frameWin.temp1,
+    "Global doesn't match the object's global with bindObjectActor");
+
+  nextTest()
+}
+
+async function forceLexicalInit() {
+  info("test that failed let/const bindings are initialized to undefined");
+
+  const testData = [
+    {
+        stmt: "let foopie = wubbalubadubdub",
+        vars: ["foopie"]
+    },
+    {
+        stmt: "let {z, w={n}=null} = {}",
+        vars: ["z", "w"]
+    },
+    {
+        stmt: "let [a, b, c] = null",
+        vars: ["a", "b", "c"]
+    },
+    {
+        stmt: "const nein1 = rofl, nein2 = copter",
+        vars: ["nein1", "nein2"]
+    },
+    {
+        stmt: "const {ha} = null",
+        vars: ["ha"]
+    },
+    {
+        stmt: "const [haw=[lame]=null] = []",
+        vars: ["haw"]
+    },
+    {
+        stmt: "const [rawr, wat=[lame]=null] = []",
+        vars: ["rawr", "haw"]
+    },
+    {
+        stmt: "let {zzz: xyz=99, zwz: wb} = nexistepas()",
+        vars: ["xyz", "wb"]
+    },
+    {
+        stmt: "let {c3pdoh=101} = null",
+        vars: ["c3pdoh"]
+    }
+  ];
+
+  for (const data of testData) {
+      const response = await evaluateJS(data.stmt);
+      checkObject(response, {
+        input: data.stmt,
+        result: undefined,
+      });
+      ok(response.exception, "expected exception");
+      for (const varName of data.vars) {
+          const response2 = await evaluateJS(varName);
+          checkObject(response2, {
+            input: varName,
+            result: undefined,
+          });
+          ok(!response2.exception, "unexpected exception");
+      }
+  }
+
+  nextTest();
+}
+
+function testEnd()
+{
+  // If this is the first run, reload the page and do it again.
+  // Otherwise, end the test.
+  closeDebugger(gState, function() {
+    gState = null;
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html b/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html
new file mode 100644
index 0000000000..8f250d84a7
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_jsterm_autocomplete.html
@@ -0,0 +1,626 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for JavaScript terminal functionality</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for JavaScript terminal autocomplete functionality</p>
+
+<script class="testbody" type="text/javascript">
+  "use strict";
+
+  SimpleTest.waitForExplicitFinish();
+  const {
+    MAX_AUTOCOMPLETE_ATTEMPTS,
+    MAX_AUTOCOMPLETIONS
+  } = require("devtools/shared/webconsole/js-property-provider");
+  const RESERVED_JS_KEYWORDS = require("devtools/shared/webconsole/reserved-js-words");
+
+
+  addEventListener("load", startTest);
+
+  async function startTest() {
+    // First run the tests with a tab as a target.
+    let {state} = await attachConsoleToTab(["PageError"]);
+    await performTests({state, isWorker: false});
+
+    // Then run the tests with a worker as a target.
+    state = (await attachConsoleToWorker(["PageError"])).state;
+    await performTests({state, isWorker: true});
+
+    SimpleTest.finish();
+  }
+
+  async function performTests({state, isWorker}) {
+    // Set up the global variables needed to test autocompletion in the target.
+    const script = `
+      // This is for workers so autocomplete acts the same
+      if (!this.window) {
+        window = this;
+      }
+
+      window.foobarObject = Object.create(null);
+      window.foobarObject.foo = 1;
+      window.foobarObject.foobar = 2;
+      window.foobarObject.foobaz = 3;
+      window.foobarObject.omg = 4;
+      window.foobarObject.omgfoo = 5;
+      window.foobarObject.strfoo = "foobarz";
+      window.foobarObject.omgstr = "foobarz" +
+        (new Array(${DevToolsServer.LONG_STRING_LENGTH})).join("abb");
+      window.largeObject1 = Object.create(null);
+      for (let i = 0; i < ${MAX_AUTOCOMPLETE_ATTEMPTS + 1}; i++) {
+        window.largeObject1['a' + i] = i;
+      }
+
+      window.largeObject2 = Object.create(null);
+      for (let i = 0; i < ${MAX_AUTOCOMPLETIONS * 2}; i++) {
+        window.largeObject2['a' + i] = i;
+      }
+
+      window.proxy1 = new Proxy({foo: 1}, {
+        getPrototypeOf() { throw new Error() }
+      });
+      window.proxy2 = new Proxy(Object.create(Object.create(null, {foo:{}})), {
+        ownKeys() { throw new Error() }
+      });
+      window.emojiObject = Object.create(null);
+      window.emojiObject["😎"] = "😎";
+
+      window.insensitiveTestCase = Object.create(null, Object.getOwnPropertyDescriptors({
+        PROP: "",
+        Prop: "",
+        prop: "",
+        PRÖP: "",
+        pröp: "",
+      }));
+
+      window.elementAccessTestCase = Object.create(null, Object.getOwnPropertyDescriptors({
+        bar: "",
+        BAR: "",
+        dataTest: "",
+        "data-test": "",
+        'da"ta"test': "",
+        'da\`ta\`test': "",
+        "da'ta'test": "",
+      }));
+
+      window.varify = true;
+    `;
+    await state.webConsoleFront.evaluateJSAsync(script);
+
+    const tests = [
+      doAutocomplete1,
+      doAutocomplete2,
+      doAutocomplete3,
+      doAutocomplete4,
+      doAutocompleteLarge1,
+      doAutocompleteLarge2,
+      doAutocompleteProxyThrowsPrototype,
+      doAutocompleteProxyThrowsOwnKeys,
+      doAutocompleteDotSurroundedBySpaces,
+      doAutocompleteAfterOr,
+      doInsensitiveAutocomplete,
+      doElementAccessAutocomplete,
+      doAutocompleteAfterOperator,
+      dontAutocompleteAfterDeclaration,
+      doKeywordsAutocomplete,
+      dontAutocomplete,
+    ];
+
+    if (!isWorker) {
+      // `Cu` is not defined in workers, then we can't test `Cu.Sandbox`
+      tests.push(doAutocompleteSandbox);
+      // Some cases are handled in worker context because we can't use parser.js.
+      // See Bug 1507181.
+      tests.push(
+        doAutocompleteArray,
+        doAutocompleteString,
+        doAutocompleteCommands,
+        doAutocompleteBracketSurroundedBySpaces,
+      );
+    }
+
+    for (const test of tests) {
+      await test(state.webConsoleFront);
+    }
+
+    // Null out proxy1 and proxy2: the proxy handlers use scripted functions
+    // that can keep the debugger sandbox alive longer than necessary via their
+    // environment chain (due to the webconsole helper functions defined there).
+    await state.webConsoleFront.evaluateJSAsync(`this.proxy1 = null; this.proxy2 = null;`);
+
+    await closeDebugger(state);
+  }
+
+  async function doAutocomplete1(webConsoleFront) {
+    info("test autocomplete for 'window.foo'");
+    const response = await webConsoleFront.autocomplete("window.foo");
+    const matches = response.matches;
+
+    is(response.matchProp, "foo", "matchProp");
+    is(matches.length, 1, "matches.length");
+    is(matches[0], "foobarObject", "matches[0]");
+  }
+
+  async function doAutocomplete2(webConsoleFront) {
+    info("test autocomplete for 'window.foobarObject.'");
+    const response = await webConsoleFront.autocomplete("window.foobarObject.");
+    const matches = response.matches;
+
+    ok(!response.matchProp, "matchProp");
+    is(matches.length, 7, "matches.length");
+    checkObject(matches,
+      ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
+  }
+
+  async function doAutocomplete3(webConsoleFront) {
+    // Check that completion suggestions are offered inside the string.
+    info("test autocomplete for 'dump(window.foobarObject.)'");
+    const response = await webConsoleFront.autocomplete("dump(window.foobarObject.)", 25);
+    const matches = response.matches;
+
+    ok(!response.matchProp, "matchProp");
+    is(matches.length, 7, "matches.length");
+    checkObject(matches,
+      ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
+  }
+
+  async function doAutocomplete4(webConsoleFront) {
+    // Check that completion requests can have no suggestions.
+    info("test autocomplete for 'dump(window.foobarObject.)'");
+    const response = await webConsoleFront.autocomplete("dump(window.foobarObject.)");
+    ok(!response.matchProp, "matchProp");
+    is(response.matches, null, "matches is null");
+  }
+
+  async function doAutocompleteLarge1(webConsoleFront) {
+    // Check that completion requests with too large objects will
+    // have no suggestions.
+    info("test autocomplete for 'window.largeObject1.'");
+    const response = await webConsoleFront.autocomplete("window.largeObject1.");
+    ok(!response.matchProp, "matchProp");
+    info (response.matches.join("|"));
+    is(response.matches.length, 0, "Bailed out with too many properties");
+  }
+
+  async function doAutocompleteLarge2(webConsoleFront) {
+    // Check that completion requests with pretty large objects will
+    // have MAX_AUTOCOMPLETIONS suggestions
+    info("test autocomplete for 'window.largeObject2.'");
+    const response = await webConsoleFront.autocomplete("window.largeObject2.");
+    ok(!response.matchProp, "matchProp");
+    is(response.matches.length, MAX_AUTOCOMPLETIONS, "matches.length is MAX_AUTOCOMPLETIONS");
+  }
+
+  async function doAutocompleteProxyThrowsPrototype(webConsoleFront) {
+    // Check that completion provides own properties even if [[GetPrototypeOf]] throws.
+    info("test autocomplete for 'window.proxy1.'");
+    const response = await webConsoleFront.autocomplete("window.proxy1.");
+    ok(!response.matchProp, "matchProp");
+    is(response.matches.length, 1, "matches.length");
+    checkObject(response.matches, ["foo"]);
+  }
+
+  async function doAutocompleteProxyThrowsOwnKeys(webConsoleFront) {
+    // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws.
+    info("test autocomplete for 'window.proxy2.'");
+    const response = await webConsoleFront.autocomplete("window.proxy2.");
+    ok(!response.matchProp, "matchProp");
+    is(response.matches.length, 1, "matches.length");
+    checkObject(response.matches, ["foo"]);
+  }
+
+  async function doAutocompleteSandbox(webConsoleFront) {
+    // Check that completion provides inherited properties even if [[OwnPropertyKeys]] throws.
+    info("test autocomplete for 'Cu.Sandbox.'");
+    const response = await webConsoleFront.autocomplete("Cu.Sandbox.");
+    ok(!response.matchProp, "matchProp");
+    const keys = Object.getOwnPropertyNames(Object.prototype).sort();
+    is(response.matches.length, keys.length, "matches.length");
+    // checkObject(response.matches, keys);
+    is(response.matches.join(" - "), keys.join(" - "));
+  }
+
+  async function doAutocompleteArray(webConsoleFront) {
+    info("test autocomplete for [1,2,3]");
+    const response = await webConsoleFront.autocomplete("[1,2,3].");
+    let {matches} = response;
+
+    ok(matches.length > 0, "There are completion results for the array");
+    ok(matches.includes("length") && matches.includes("filter"),
+      "Array autocomplete contains expected results");
+
+    info("test autocomplete for '[] . '");
+    matches = (await webConsoleFront.autocomplete("[] . ")).matches;
+    ok(matches.length > 1);
+    ok(matches.includes("length") && matches.includes("filter"),
+      "Array autocomplete contains expected results");
+    ok(!matches.includes("copy"), "Array autocomplete does not contain helpers");
+
+    info("test autocomplete for '[1,2,3]['");
+    matches = (await webConsoleFront.autocomplete("[1,2,3][")).matches;
+    ok(matches.length > 1);
+    ok(matches.includes('"length"') && matches.includes('"filter"'),
+      "Array autocomplete contains expected results, surrounded by quotes");
+
+    info("test autocomplete for '[1,2,3]['");
+    matches = (await webConsoleFront.autocomplete("[1,2,3]['")).matches;
+    ok(matches.length > 1);
+    ok(matches.includes("'length'") && matches.includes("'filter'"),
+      "Array autocomplete contains expected results, surrounded by quotes");
+
+    info("test autocomplete for '[1,2,3][l");
+    matches = (await webConsoleFront.autocomplete("[1,2,3][l")).matches;
+    ok(matches.length >= 1);
+    ok(matches.includes('"length"'),
+      "Array autocomplete contains expected results, surrounded by quotes");
+
+    info("test autocomplete for '[1,2,3]['l");
+    matches = (await webConsoleFront.autocomplete("[1,2,3]['l")).matches;
+    ok(matches.length >= 1);
+    ok(matches.includes("'length'"),
+      "Array autocomplete contains expected results, surrounded by quotes");
+  }
+
+  async function doAutocompleteString(webConsoleFront) {
+    info(`test autocomplete for "foo".`);
+    const response = await webConsoleFront.autocomplete(`"foo".`);
+    let {matches} = response;
+
+    ok(matches.length > 0, "There are completion results for the string");
+    ok(matches.includes("substr") && matches.includes("trim"),
+      "String autocomplete contains expected results");
+
+    info("test autocomplete for `foo`[");
+    matches = (await webConsoleFront.autocomplete("`foo`[")).matches;
+    ok(matches.length > 1, "autocomplete string with bracket works");
+    ok(matches.includes('"substr"') && matches.includes('"trim"'),
+      "String autocomplete contains expected results, surrounded by quotes");
+  }
+
+  async function doAutocompleteDotSurroundedBySpaces(webConsoleFront) {
+    info("test autocomplete for 'window.foobarObject\n  .'");
+    let {matches} = await webConsoleFront.autocomplete("window.foobarObject\n  .");
+    is(matches.length, 7);
+    checkObject(matches,
+      ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
+
+    info("test autocomplete for 'window.foobarObject\n  .o'");
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .o")).matches;
+    is(matches.length, 3);
+    checkObject(matches, ["omg", "omgfoo", "omgstr"]);
+
+    info("test autocomplete for 'window.foobarObject\n  .\n  s'");
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .\n  s")).matches;
+    is(matches.length, 1);
+    checkObject(matches, ["strfoo"]);
+
+    info("test autocomplete for 'window.foobarObject\n  .  '");
+    matches = (await webConsoleFront.autocomplete("window.foobarObject\n  .  ")).matches;
+    is(matches.length, 7);
+    checkObject(matches,
+      ["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]);
+
+    matches =
+      (await webConsoleFront.autocomplete("window.foobarObject.  foo ; window.foo")).matches;
+    is(matches.length, 1);
+    checkObject(matches, ["foobarObject"]);
+  }
+
+  async function doAutocompleteBracketSurroundedBySpaces(webConsoleFront) {
+    const wrap = (arr, quote = `"`) => arr.map(x => `${quote}${x}${quote}`);
+    let matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [")
+    is(matches.length, 7);
+    checkObject(matches,
+      wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]));
+
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  ['o")
+    is(matches.length, 3);
+    checkObject(matches, wrap(["omg", "omgfoo", "omgstr"], "'"));
+
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [\n  s");
+    is(matches.length, 1);
+    checkObject(matches, [`"strfoo"`]);
+
+    matches = await getAutocompleteMatches(webConsoleFront, "window.foobarObject\n  [  ");
+    is(matches.length, 7);
+    checkObject(matches,
+      wrap(["foo", "foobar", "foobaz", "omg", "omgfoo", "omgstr", "strfoo"]));
+
+    matches = await getAutocompleteMatches(webConsoleFront, "window.emojiObject  [   '");
+    is(matches.length, 1);
+    checkObject(matches, [`'😎'`]);
+  }
+
+  async function doAutocompleteAfterOr(webConsoleFront) {
+    info("test autocomplete for 'true || foo'");
+    const {matches} = await webConsoleFront.autocomplete("true || foobar");
+    is(matches.length, 1, "autocomplete returns expected results");
+    is(matches.join("-"), "foobarObject");
+  }
+
+  async function doInsensitiveAutocomplete(webConsoleFront) {
+    info("test autocomplete for 'window.insensitiveTestCase.'");
+    let {matches} = await webConsoleFront.autocomplete("window.insensitiveTestCase.");
+    is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP",
+      "autocomplete returns the expected items, in the expected order");
+
+    info("test autocomplete for 'window.insensitiveTestCase.p'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.p")).matches;
+    is(matches.join("-"), "prop-pröp-Prop-PROP-PRÖP",
+      "autocomplete is case-insensitive when first letter is lowercased");
+
+    info("test autocomplete for 'window.insensitiveTestCase.pRoP'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.pRoP")).matches;
+    is(matches.join("-"), "prop-Prop-PROP",
+      "autocomplete is case-insensitive when first letter is lowercased");
+
+    info("test autocomplete for 'window.insensitiveTestCase.P'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.P")).matches;
+    is(matches.join("-"), "Prop-PROP-PRÖP",
+      "autocomplete is case-sensitive when first letter is uppercased");
+
+    info("test autocomplete for 'window.insensitiveTestCase.PROP'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PROP")).matches;
+    is(matches.join("-"), "PROP",
+      "autocomplete is case-sensitive when first letter is uppercased");
+
+    info("test autocomplete for 'window.insensitiveTestCase.prö'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.prö")).matches;
+    is(matches.join("-"), "pröp-PRÖP", "expected result with lowercase diacritic");
+
+    info("test autocomplete for 'window.insensitiveTestCase.PRÖ'");
+    matches = (await webConsoleFront.autocomplete("window.insensitiveTestCase.PRÖ")).matches;
+    is(matches.join("-"), "PRÖP", "expected result with uppercase diacritic");
+  }
+
+  async function doElementAccessAutocomplete(webConsoleFront) {
+    info("test autocomplete for 'window.elementAccessTestCase['");
+    let res = (await webConsoleFront.autocomplete("window.elementAccessTestCase["));
+    is(
+      res.matches.join("|"),
+      `"bar"|"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"|"BAR"`,
+      "autocomplete returns the expected items, wrapped in quotes");
+    is(res.isElementAccess, true);
+
+    info("test autocomplete for 'window.elementAccessTestCase[d'");
+    res = await webConsoleFront.autocomplete("window.elementAccessTestCase[d");
+    is(
+      res.matches.join("|"),
+      `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`,
+      "autocomplete returns the expected filtered items");
+    is(res.isElementAccess, true);
+
+    info(`test autocomplete for 'window.elementAccessTestCase["d'`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["d`);
+    is(
+      res.matches.join("|"),
+      `"da'ta'test"|"da\\"ta\\"test"|"da\`ta\`test"|"data-test"|"dataTest"`,
+      "autocomplete returns the expected items, wrapped in quotes");
+    is(res.isElementAccess, true);
+
+    info(`test autocomplete for 'window.elementAccessTestCase["data-`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase["data-`);
+    is(res.matches.join("|"), `"data-test"`,
+      "autocomplete returns the expected items, wrapped in quotes");
+    is(res.isElementAccess, true);
+
+    info(`test autocomplete for 'window.elementAccessTestCase['d'`);
+    res = await webConsoleFront.autocomplete(`window.elementAccessTestCase['d`);
+    is(
+      res.matches.join("|"),
+      `'da"ta"test'|'da\\'ta\\'test'|'da\`ta\`test'|'data-test'|'dataTest'`,
+      "autocomplete returns the expected items, wrapped in the same quotes the user entered");
+    is(res.isElementAccess, true);
+
+    info("test autocomplete for 'window.elementAccessTestCase[`d'");
+    res = await webConsoleFront.autocomplete("window.elementAccessTestCase[`d");
+    is(
+      res.matches.join("|"),
+      "`da'ta'test`|`da\"ta\"test`|`da\\`ta\\`test`|`data-test`|`dataTest`",
+      "autocomplete returns the expected items, wrapped in the same quotes the user entered");
+    is(res.isElementAccess, true);
+
+    info(`test autocomplete for '['`);
+    res = await webConsoleFront.autocomplete(`[`);
+    is(res.matches, null, "it does not return anything");
+
+    info(`test autocomplete for '[1,2,3'`);
+    res = await webConsoleFront.autocomplete(`[1,2,3`);
+    is(res.matches, null, "it does not return anything");
+
+    info(`test autocomplete for '["'`);
+    res = await webConsoleFront.autocomplete(`["`);
+    is(res.matches, null, "it does not return anything");
+
+    info(`test autocomplete for '[;'`);
+    res = await webConsoleFront.autocomplete(`[;`);
+    is(res.matches, null, "it does not return anything");
+  }
+
+  async function doAutocompleteCommands(webConsoleFront) {
+    info("test autocomplete for 'c'");
+    let matches = (await webConsoleFront.autocomplete("c")).matches;
+    ok(matches.includes("clear"), "commands are returned");
+
+    info("test autocomplete for 's'");
+    matches = (await webConsoleFront.autocomplete("s")).matches;
+    is(matches.includes("screenshot"), false, "screenshot is not returned");
+
+    info("test autocomplete for ':s'");
+    matches = (await webConsoleFront.autocomplete(":s")).matches;
+    is(matches.includes(":screenshot"), true, "screenshot is returned");
+
+    info("test autocomplete for 'window.c'");
+    matches = (await webConsoleFront.autocomplete("window.c")).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+
+    info("test autocomplete for 'window[c'");
+    matches = (await webConsoleFront.autocomplete("window[c")).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+
+    info(`test autocomplete for 'window["c'`);
+    matches = (await webConsoleFront.autocomplete(`window["c`)).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+
+    info(`test autocomplete for 'window["c'`);
+    matches = (await webConsoleFront.autocomplete(`window["c`)).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+
+    info(`test autocomplete for 'window[";c'`);
+    matches = (await webConsoleFront.autocomplete(`window[";c`)).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+
+    info(`test autocomplete for 'window[;c'`);
+    matches = (await webConsoleFront.autocomplete(`window[;c`)).matches;
+    ok(!matches.includes("clear"), "commands are not returned");
+  }
+
+  async function doAutocompleteAfterOperator(webConsoleFront) {
+    const inputs = [
+      "true;foob",
+      "true,foob",
+      "({key:foob",
+      "a=foob",
+      "if(a<foob",
+      "if(a>foob",
+      "1+foob",
+      "1-foob",
+      "++foob",
+      "--foob",
+      "1*foob",
+      "2**foob",
+      "1/foob",
+      "1%foob",
+      "1|foob",
+      "1&foob",
+      "1^foob",
+      "~foob",
+      "1<<foob",
+      "1>>foob",
+      "1>>>foob",
+      "false||foob",
+      "false&&foob",
+      "x=true?foob",
+      "x=false?1:foob",
+      "!foob",
+      "false??foob",
+    ];
+
+    for (const input of inputs) {
+      info(`test autocomplete for "${input}"`);
+      const matches = (await webConsoleFront.autocomplete(input)).matches;
+      ok(matches.includes("foobarObject"), `Expected autocomplete result for ${input}"`);
+    }
+  }
+
+  async function dontAutocompleteAfterDeclaration(webConsoleFront) {
+    info("test autocomplete for 'var win'");
+    let matches = (await webConsoleFront.autocomplete("var win")).matches;
+    is(matches, null, "no autocompletion on a var declaration");
+
+    info("test autocomplete for 'const win'");
+    matches = (await webConsoleFront.autocomplete("const win")).matches;
+    is(matches, null, "no autocompletion on a const declaration");
+
+    info("test autocomplete for 'let win'");
+    matches = (await webConsoleFront.autocomplete("let win")).matches;
+    is(matches, null, "no autocompletion on a let declaration");
+
+    info("test autocomplete for 'function win'");
+    matches = (await webConsoleFront.autocomplete("function win")).matches;
+    is(matches, null, "no autocompletion on a function declaration");
+
+    info("test autocomplete for 'class win'");
+    matches = (await webConsoleFront.autocomplete("class win")).matches;
+    is(matches, null, "no autocompletion on a class declaration");
+
+    info("test autocomplete for 'const win = win'");
+    matches = (await webConsoleFront.autocomplete("const win = win")).matches;
+    ok(matches.includes("window"), "autocompletion still happens after the `=` sign");
+
+    info("test autocomplete for 'in var'");
+    matches = (await webConsoleFront.autocomplete("in var")).matches;
+    ok(matches.includes("varify"),
+      "autocompletion still happens with a property name starting with 'var'");
+}
+
+async function doKeywordsAutocomplete(webConsoleFront) {
+  info("test autocomplete for 'func'");
+  let matches = (await webConsoleFront.autocomplete("func")).matches;
+  ok(matches.includes("function"), "keywords are returned");
+
+  info("test autocomplete for ':func'");
+  matches = (await webConsoleFront.autocomplete(":func")).matches;
+  is(!matches.includes("function"), true,
+    "'function' is not returned when prefixed with ':'");
+
+  info("test autocomplete for 'window.func'");
+  matches = (await webConsoleFront.autocomplete("window.func")).matches;
+  ok(!matches.includes("function"),
+    "'function' is not returned when doing a property access");
+
+  info("test autocomplete for 'window[func'");
+  matches = (await webConsoleFront.autocomplete("window[func")).matches;
+  ok(!matches.includes("function"),
+    "'function' is not returned when doing an element access");
+  }
+
+  async function dontAutocomplete(webConsoleFront) {
+    const inputs = [
+      "",
+      "       ",
+      "\n",
+      "\n  ",
+      "  \n  ",
+      "  \n",
+      "true;",
+      "true,",
+      "({key:",
+      "a=",
+      "if(a<",
+      "if(a>",
+      "1+",
+      "1-",
+      "++",
+      "--",
+      "1*",
+      "2**",
+      "1/",
+      "1%",
+      "1|",
+      "1&",
+      "1^",
+      "~",
+      "1<<",
+      "1>>",
+      "1>>>",
+      "false||",
+      "false&&",
+      "x=true?",
+      "x=false?1:",
+      "!",
+      ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword} `),
+      ...RESERVED_JS_KEYWORDS.map(keyword => `${keyword}  `),
+    ];
+    for (const input of inputs) {
+      info(`test autocomplete for "${input}"`);
+      const matches = (await webConsoleFront.autocomplete(input)).matches;
+      is(matches, null, `No autocomplete result for ${input}"`);
+    }
+  }
+
+  async function getAutocompleteMatches(webConsoleFront, input) {
+    info(`test autocomplete for "${input}"`);
+    const res = (await webConsoleFront.autocomplete(input));
+    return res.matches;
+  }
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_jsterm_last_result.html b/devtools/shared/webconsole/test/chrome/test_jsterm_last_result.html
new file mode 100644
index 0000000000..a61a7bb851
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_jsterm_last_result.html
@@ -0,0 +1,122 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the $_ getter</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the $_ getter</p>
+
+<iframe id="content-iframe" src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/sandboxed_iframe.html"></iframe>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+let gState;
+
+function evaluateJS(input) {
+  return gState.webConsoleFront.evaluateJSAsync(input);
+}
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+  gState = (await attachConsoleToTab([])).state;
+  const tests = [checkUndefinedResult,checkAdditionResult,checkObjectResult];
+  runTests(tests, testEnd);
+}
+
+const checkUndefinedResult = async function () {
+  info ("$_ returns undefined if nothing has evaluated yet");
+  const response = await evaluateJS("$_");
+  basicResultCheck(response, "$_", undefined);
+  nextTest();
+};
+
+const checkAdditionResult = async function () {
+  info ("$_ returns last value and performs basic arithmetic");
+  let response = await evaluateJS("2+2");
+  basicResultCheck(response, "2+2", 4);
+
+  response = await evaluateJS("$_");
+  basicResultCheck(response, "$_", 4);
+
+  response = await evaluateJS("$_ + 2");
+  basicResultCheck(response, "$_ + 2", 6);
+
+  response = await evaluateJS("$_ + 4");
+  basicResultCheck(response, "$_ + 4", 10);
+
+  nextTest();
+};
+
+const checkObjectResult = async function () {
+  info ("$_ has correct references to objects");
+
+  let response = await evaluateJS("var foo = {bar:1}; foo;");
+  basicResultCheck(response, "var foo = {bar:1}; foo;", {
+    type: "object",
+    class: "Object",
+    actor: /[a-z]/,
+  });
+  checkObject(response.result.getGrip().preview.ownProperties, {
+    bar: {
+      value: 1
+    }
+  });
+
+  response = await evaluateJS("$_");
+  basicResultCheck(response, "$_", {
+    type: "object",
+    class: "Object",
+    actor: /[a-z]/,
+  });
+  checkObject(response.result.getGrip().preview.ownProperties, {
+    bar: {
+      value: 1
+    }
+  });
+
+  top.foo.bar = 2;
+
+  response = await evaluateJS("$_");
+  basicResultCheck(response, "$_", {
+    type: "object",
+    class: "Object",
+    actor: /[a-z]/,
+  });
+  checkObject(response.result.getGrip().preview.ownProperties, {
+    bar: {
+      value: 2
+    }
+  });
+
+  nextTest();
+};
+
+function basicResultCheck(response, input, output) {
+  checkObject(response, {
+    input: input,
+    result: output,
+  });
+  ok(!response.exception, "no eval exception");
+  ok(!response.helperResult, "no helper result");
+}
+
+function testEnd()
+{
+  closeDebugger(gState, function() {
+    gState = null;
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_jsterm_queryselector.html b/devtools/shared/webconsole/test/chrome/test_jsterm_queryselector.html
new file mode 100644
index 0000000000..fb6086c46b
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_jsterm_queryselector.html
@@ -0,0 +1,159 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the querySelector / querySelectorAll helpers</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the querySelector / querySelectorAll helpers</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+let gState;
+let gWin;
+
+function evaluateJS(input) {
+  return gState.webConsoleFront.evaluateJSAsync(input);
+}
+
+async function startTest() {
+  info ("Content window opened, attaching console to it");
+
+  const systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal);
+  ok (!gWin.document.nodePrincipal.equals(systemPrincipal),
+      "The test document is not using the system principal");
+
+  gState = (await attachConsoleToTab([])).state;
+  const tests = [
+    setupWindow,
+    checkQuerySelector,
+    checkQuerySelectorAll,
+    checkQuerySelectorAllNotExist,
+    checkQuerySelectorException,
+    checkQuerySelectorAllException
+  ];
+  runTests(tests, testEnd);
+}
+
+const setupWindow = async function () {
+  info ("Shimming window functions for the content privileged tab");
+  await evaluateJS("document.querySelector = function() { throw 'should not call qS'; }");
+  await evaluateJS("document.querySelectorAll = function() { throw 'should not call qSA'; }");
+  nextTest();
+};
+
+const checkQuerySelector = async function () {
+  info ("$ returns an DOMNode");
+  const response = await evaluateJS("$('body')");
+  basicResultCheck(response, "$('body')", {
+    type: "object",
+    class: "HTMLBodyElement",
+    preview: {
+      kind: "DOMNode",
+      nodeName: "body"
+    }
+  });
+  nextTest();
+};
+
+const checkQuerySelectorAll = async function () {
+  info ("$$ returns an array");
+  const response = await evaluateJS("$$('body')");
+  basicResultCheck(response, "$$('body')", {
+    type: "object",
+    class: "Array",
+    preview: {
+      length: 1
+    }
+  });
+  nextTest();
+};
+
+const checkQuerySelectorAllNotExist = async function () {
+  info ("$$ returns an array even if query yields no results");
+  const response = await evaluateJS("$$('foobar')");
+  basicResultCheck(response, "$$('foobar')", {
+    type: "object",
+    class: "Array",
+    preview: {
+      length: 0
+    }
+  });
+  nextTest();
+};
+
+const checkQuerySelectorException = async function () {
+  info ("$ returns an exception if an invalid selector was provided");
+  const response = await evaluateJS("$(':foo')");
+  checkObject(response, {
+    input: "$(':foo')",
+    exceptionMessage: "SyntaxError: Document.querySelector: ':foo' is not a valid selector",
+    exception: {
+      type: "object",
+      class: "DOMException",
+      preview: {
+        kind: "DOMException",
+        name: "SyntaxError",
+        message: "Document.querySelector: ':foo' is not a valid selector"
+      }
+    }
+  });
+  nextTest();
+};
+
+const checkQuerySelectorAllException = async function () {
+  info ("$$ returns an exception if an invalid selector was provided");
+  const response = await evaluateJS("$$(':foo')");
+  checkObject(response, {
+    input: "$$(':foo')",
+    exceptionMessage: "SyntaxError: Document.querySelectorAll: ':foo' is not a valid selector",
+    exception: {
+      type: "object",
+      class: "DOMException",
+      preview: {
+        kind: "DOMException",
+        name: "SyntaxError",
+        message: "Document.querySelectorAll: ':foo' is not a valid selector"
+      }
+    }
+  });
+  nextTest();
+};
+
+function basicResultCheck(response, input, output) {
+  checkObject(response, {
+    input: input,
+    result: output,
+  });
+  ok(!response.exception, "no eval exception");
+  ok(!response.helperResult, "no helper result");
+}
+
+function testEnd() {
+  gWin.close();
+  gWin = null;
+  closeDebugger(gState, function() {
+    gState = null;
+    SimpleTest.finish();
+  });
+}
+
+const load = async function () {
+  removeEventListener("load", load);
+
+  // Open a content window to test XRay functionality on built in functions.
+  gWin = window.open("javascript:'<html><body>dummy</body></html>';");
+  info ("Waiting for content window to load");
+  gWin.onload = startTest;
+};
+addEventListener("load", load);
+
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_network_get.html b/devtools/shared/webconsole/test/chrome/test_network_get.html
new file mode 100644
index 0000000000..9f3b9c2a83
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_network_get.html
@@ -0,0 +1,259 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the network actor (GET request)</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the network actor (GET request)</p>
+
+<iframe src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+  const {state} = await attachConsoleToTab(["NetworkActivity"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  info("test network GET request");
+
+  onNetworkEvent = onNetworkEvent.bind(null, aState);
+  aState.webConsoleFront.on("serverNetworkEvent", onNetworkEvent);
+  onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);
+  aState.dbgClient.on("networkEventUpdate", onNetworkEventUpdate);
+
+  const iframe = document.querySelector("iframe").contentWindow;
+  iframe.wrappedJSObject.testXhrGet();
+}
+
+function onNetworkEvent(aState, aPacket)
+{
+  info("checking the network event packet");
+
+  const netActor = aPacket.eventActor;
+
+  checkObject(netActor, {
+    actor: /[a-z]/,
+    startedDateTime: /^\d+\-\d+\-\d+T.+$/,
+    url: /data\.json/,
+    method: "GET",
+  });
+
+  aState.netActor = netActor.actor;
+
+  aState.webConsoleFront.off("serverNetworkEvent", onNetworkEvent);
+}
+
+const updates = [];
+
+function onNetworkEventUpdate(aState, aPacket)
+{
+  info("received networkEventUpdate " + aPacket.updateType);
+  is(aPacket.from, aState.netActor, "networkEventUpdate actor");
+
+  updates.push(aPacket.updateType);
+
+  let expectedPacket = null;
+
+  switch (aPacket.updateType) {
+    case "requestHeaders":
+    case "responseHeaders":
+      ok(aPacket.headers > 0, "headers > 0");
+      ok(aPacket.headersSize > 0, "headersSize > 0");
+      break;
+    case "requestCookies":
+      expectedPacket = {
+        cookies: 3,
+      };
+      break;
+    case "requestPostData":
+      ok(false, "got unexpected requestPostData");
+      break;
+    case "responseStart":
+      expectedPacket = {
+        response: {
+          httpVersion: /^HTTP\/\d\.\d$/,
+          status: "200",
+          statusText: "OK",
+          headersSize: /^\d+$/,
+        },
+      };
+      break;
+    case "securityInfo":
+      expectedPacket = {
+        state: "insecure",
+      };
+      break;
+    case "responseCookies":
+      expectedPacket = {
+        cookies: 0,
+      };
+      break;
+    case "responseContent":
+      expectedPacket = {
+        mimeType: "application/json",
+        contentSize: 1070,
+      };
+      break;
+    case "eventTimings":
+      expectedPacket = {
+        totalTime: /^\d+$/,
+      };
+      break;
+    default:
+      ok(false, "unknown network event update type: " +
+         aPacket.updateType);
+      return;
+  }
+
+  if (expectedPacket) {
+    info("checking the packet content");
+    checkObject(aPacket, expectedPacket);
+  }
+
+  if (updates.indexOf("responseContent") > -1 &&
+      updates.indexOf("eventTimings") > -1) {
+    aState.dbgClient.off("networkEventUpdate",
+                                    onNetworkEventUpdate);
+
+    onRequestHeaders = onRequestHeaders.bind(null, aState);
+    aState.webConsoleFront.getRequestHeaders(aState.netActor,
+                                    onRequestHeaders);
+  }
+}
+
+function onRequestHeaders(aState, aResponse)
+{
+  info("checking request headers");
+
+  ok(aResponse.headers.length > 0, "request headers > 0");
+  ok(aResponse.headersSize > 0, "request headersSize > 0");
+  ok(!!aResponse.rawHeaders, "request rawHeaders available");
+
+  checkHeadersOrCookies(aResponse.headers, {
+    Referer: /network_requests_iframe\.html/,
+    Cookie: /bug768096/,
+  });
+
+  checkRawHeaders(aResponse.rawHeaders, {
+    Referer: /network_requests_iframe\.html/,
+    Cookie: /bug768096/,
+  });
+
+  onRequestCookies = onRequestCookies.bind(null, aState);
+  aState.webConsoleFront.getRequestCookies(aState.netActor,
+                                  onRequestCookies);
+}
+
+function onRequestCookies(aState, aResponse)
+{
+  info("checking request cookies");
+
+  is(aResponse.cookies.length, 3, "request cookies length");
+
+  checkHeadersOrCookies(aResponse.cookies, {
+    foobar: "fooval",
+    omgfoo: "bug768096",
+    badcookie: "bug826798=st3fan",
+  });
+
+  onRequestPostData = onRequestPostData.bind(null, aState);
+  aState.webConsoleFront.getRequestPostData(aState.netActor,
+                                   onRequestPostData);
+}
+
+function onRequestPostData(aState, aResponse)
+{
+  info("checking request POST data");
+
+  ok(!aResponse.postData.text, "no request POST data");
+  ok(!aResponse.postDataDiscarded, "request POST data was not discarded");
+
+  onResponseHeaders = onResponseHeaders.bind(null, aState);
+  aState.webConsoleFront.getResponseHeaders(aState.netActor,
+                                   onResponseHeaders);
+}
+
+function onResponseHeaders(aState, aResponse)
+{
+  info("checking response headers");
+
+  ok(aResponse.headers.length > 0, "response headers > 0");
+  ok(aResponse.headersSize > 0, "response headersSize > 0");
+  ok(!!aResponse.rawHeaders, "response rawHeaders available");
+
+  checkHeadersOrCookies(aResponse.headers, {
+    "content-type": /^application\/(json|octet-stream)$/,
+    "content-length": /^\d+$/,
+  });
+
+  checkRawHeaders(aResponse.rawHeaders, {
+    "content-type": /^application\/(json|octet-stream)$/,
+    "content-length": /^\d+$/,
+  });
+
+  onResponseCookies = onResponseCookies.bind(null, aState);
+  aState.webConsoleFront.getResponseCookies(aState.netActor,
+                                  onResponseCookies);
+}
+
+function onResponseCookies(aState, aResponse)
+{
+  info("checking response cookies");
+
+  is(aResponse.cookies.length, 0, "response cookies length");
+
+  onResponseContent = onResponseContent.bind(null, aState);
+  aState.webConsoleFront.getResponseContent(aState.netActor,
+                                   onResponseContent);
+}
+
+function onResponseContent(aState, aResponse)
+{
+  info("checking response content");
+
+  ok(aResponse.content.text, "response content text");
+  ok(!aResponse.contentDiscarded, "response content was not discarded");
+
+  onEventTimings = onEventTimings.bind(null, aState);
+  aState.webConsoleFront.getEventTimings(aState.netActor,
+                                onEventTimings);
+}
+
+function onEventTimings(aState, aResponse)
+{
+  info("checking event timings");
+
+  checkObject(aResponse, {
+    timings: {
+      blocked: /^-1|\d+$/,
+      dns: /^-1|\d+$/,
+      connect: /^-1|\d+$/,
+      send: /^-1|\d+$/,
+      wait: /^-1|\d+$/,
+      receive: /^-1|\d+$/,
+    },
+    totalTime: /^\d+$/,
+  });
+
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_network_post.html b/devtools/shared/webconsole/test/chrome/test_network_post.html
new file mode 100644
index 0000000000..fb350ca1cb
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_network_post.html
@@ -0,0 +1,270 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the network actor (POST request)</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the network actor (POST request)</p>
+
+<iframe src="http://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+
+  const {state} = await attachConsoleToTab(["NetworkActivity"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  info("test network POST request");
+
+  onNetworkEvent = onNetworkEvent.bind(null, aState);
+  aState.webConsoleFront.on("serverNetworkEvent", onNetworkEvent);
+  onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);
+  aState.dbgClient.on("networkEventUpdate", onNetworkEventUpdate);
+
+  const iframe = document.querySelector("iframe").contentWindow;
+  iframe.wrappedJSObject.testXhrPost();
+}
+
+function onNetworkEvent(aState, aPacket)
+{
+  info("checking the network event packet");
+
+  const netActor = aPacket.eventActor;
+
+  checkObject(netActor, {
+    actor: /[a-z]/,
+    startedDateTime: /^\d+\-\d+\-\d+T.+$/,
+    url: /data\.json/,
+    method: "POST",
+  });
+
+  aState.netActor = netActor.actor;
+
+  aState.webConsoleFront.off("serverNetworkEvent", onNetworkEvent);
+}
+
+const updates = [];
+
+function onNetworkEventUpdate(aState, aPacket)
+{
+  info("received networkEventUpdate " + aPacket.updateType);
+  is(aPacket.from, aState.netActor, "networkEventUpdate actor");
+
+  updates.push(aPacket.updateType);
+
+  let expectedPacket = null;
+
+  switch (aPacket.updateType) {
+    case "requestHeaders":
+    case "responseHeaders":
+      ok(aPacket.headers > 0, "headers > 0");
+      ok(aPacket.headersSize > 0, "headersSize > 0");
+      break;
+    case "requestCookies":
+      expectedPacket = {
+        cookies: 3,
+      };
+      break;
+    case "requestPostData":
+      ok(aPacket.dataSize > 0, "dataSize > 0");
+      break;
+    case "responseStart":
+      expectedPacket = {
+        response: {
+          httpVersion: /^HTTP\/\d\.\d$/,
+          status: "200",
+          statusText: "OK",
+          headersSize: /^\d+$/,
+        },
+      };
+      break;
+    case "securityInfo":
+      expectedPacket = {
+        state: "insecure",
+      };
+      break;
+    case "responseCookies":
+      expectedPacket = {
+        cookies: 0,
+      };
+      break;
+    case "responseContent":
+      expectedPacket = {
+        mimeType: "application/json",
+        contentSize: /^\d+$/,
+      };
+      break;
+    case "eventTimings":
+      expectedPacket = {
+        totalTime: /^\d+$/,
+      };
+      break;
+    default:
+      ok(false, "unknown network event update type: " +
+         aPacket.updateType);
+      return;
+  }
+
+  if (expectedPacket) {
+    info("checking the packet content");
+    checkObject(aPacket, expectedPacket);
+  }
+
+  if (updates.indexOf("responseContent") > -1 &&
+      updates.indexOf("eventTimings") > -1) {
+    aState.dbgClient.off("networkEventUpdate",
+                                    onNetworkEvent);
+
+    onRequestHeaders = onRequestHeaders.bind(null, aState);
+    aState.webConsoleFront.getRequestHeaders(aState.netActor,
+                                    onRequestHeaders);
+  }
+}
+
+function onRequestHeaders(aState, aResponse)
+{
+  info("checking request headers");
+
+  ok(aResponse.headers.length > 0, "request headers > 0");
+  ok(aResponse.headersSize > 0, "request headersSize > 0");
+  ok(!!aResponse.rawHeaders.length, "request rawHeaders available");
+
+  checkHeadersOrCookies(aResponse.headers, {
+    Referer: /network_requests_iframe\.html/,
+    Cookie: /bug768096/,
+  });
+
+  checkRawHeaders(aResponse.rawHeaders, {
+    Referer: /network_requests_iframe\.html/,
+    Cookie: /bug768096/,
+  });
+
+  onRequestCookies = onRequestCookies.bind(null, aState);
+  aState.webConsoleFront.getRequestCookies(aState.netActor,
+                                  onRequestCookies);
+}
+
+function onRequestCookies(aState, aResponse)
+{
+  info("checking request cookies");
+
+  is(aResponse.cookies.length, 3, "request cookies length");
+
+  checkHeadersOrCookies(aResponse.cookies, {
+    foobar: "fooval",
+    omgfoo: "bug768096",
+    badcookie: "bug826798=st3fan",
+  });
+
+  onRequestPostData = onRequestPostData.bind(null, aState);
+  aState.webConsoleFront.getRequestPostData(aState.netActor,
+                                   onRequestPostData);
+}
+
+function onRequestPostData(aState, aResponse)
+{
+  info("checking request POST data");
+
+  checkObject(aResponse, {
+    postData: {
+      text: /^Hello world! foobaz barr.+foobaz barr$/,
+    },
+    postDataDiscarded: false,
+  });
+
+  is(aResponse.postData.text.length, 552, "postData text length");
+
+  onResponseHeaders = onResponseHeaders.bind(null, aState);
+  aState.webConsoleFront.getResponseHeaders(aState.netActor,
+                                   onResponseHeaders);
+}
+
+function onResponseHeaders(aState, aResponse)
+{
+  info("checking response headers");
+
+  ok(aResponse.headers.length > 0, "response headers > 0");
+  ok(aResponse.headersSize > 0, "response headersSize > 0");
+  ok(!!aResponse.rawHeaders, "response rawHeaders available");
+
+  checkHeadersOrCookies(aResponse.headers, {
+    "content-type": /^application\/(json|octet-stream)$/,
+    "content-length": /^\d+$/,
+  });
+
+  checkRawHeaders(aResponse.rawHeaders, {
+    "content-type": /^application\/(json|octet-stream)$/,
+    "content-length": /^\d+$/,
+  });
+
+  onResponseCookies = onResponseCookies.bind(null, aState);
+  aState.webConsoleFront.getResponseCookies(aState.netActor,
+                                  onResponseCookies);
+}
+
+function onResponseCookies(aState, aResponse)
+{
+  info("checking response cookies");
+
+  is(aResponse.cookies.length, 0, "response cookies length");
+
+  onResponseContent = onResponseContent.bind(null, aState);
+  aState.webConsoleFront.getResponseContent(aState.netActor,
+                                   onResponseContent);
+}
+
+function onResponseContent(aState, aResponse)
+{
+  info("checking response content");
+
+  checkObject(aResponse, {
+    content: {
+      text: /"test JSON data"/,
+    },
+    contentDiscarded: false,
+  });
+
+  onEventTimings = onEventTimings.bind(null, aState);
+  aState.webConsoleFront.getEventTimings(aState.netActor,
+                                onEventTimings);
+}
+
+function onEventTimings(aState, aResponse)
+{
+  info("checking event timings");
+
+  checkObject(aResponse, {
+    timings: {
+      blocked: /^-1|\d+$/,
+      dns: /^-1|\d+$/,
+      connect: /^-1|\d+$/,
+      send: /^-1|\d+$/,
+      wait: /^-1|\d+$/,
+      receive: /^-1|\d+$/,
+    },
+    totalTime: /^\d+$/,
+  });
+
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html b/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html
new file mode 100644
index 0000000000..2eef4cef41
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_network_security-hsts.html
@@ -0,0 +1,102 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the network actor (HSTS detection)</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the network actor (HSTS detection)</p>
+
+<iframe src="https://example.com/chrome/devtools/shared/webconsole/test/chrome/network_requests_iframe.html"></iframe>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+let gCurrentTestCase = -1;
+const TEST_CASES = [
+  {
+    desc: "no HSTS",
+    url: "https://example.com",
+    usesHSTS: false,
+  },
+  {
+    desc: "HSTS from this response",
+    url: "https://example.com/"+
+         "browser/browser/base/content/test/general/browser_star_hsts.sjs",
+    usesHSTS: true,
+  },
+  {
+    desc: "stored HSTS from previous response",
+    url: "https://example.com/",
+    usesHSTS: true,
+  }
+];
+
+async function startTest()
+{
+
+  SimpleTest.registerCleanupFunction(() => {
+    // Reset HSTS state.
+    const gSSService = Cc["@mozilla.org/ssservice;1"]
+                       .getService(Ci.nsISiteSecurityService);
+
+    const gIOService = Services.io;
+
+    const uri = gIOService.newURI(TEST_CASES[0].url);
+    gSSService.resetState(Ci.nsISiteSecurityService.HEADER_HSTS, uri, 0);
+  });
+
+  info("Test detection of HTTP Strict Transport Security.");
+  removeEventListener("load", startTest);
+  const {state} = await attachConsoleToTab(["NetworkActivity"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  onNetworkEventUpdate = onNetworkEventUpdate.bind(null, aState);
+  aState.dbgClient.on("networkEventUpdate", onNetworkEventUpdate);
+
+  runNextCase(aState);
+}
+
+function runNextCase(aState) {
+  gCurrentTestCase++;
+  if (gCurrentTestCase === TEST_CASES.length) {
+    info("Tests ran. Cleaning up.");
+    closeDebugger(aState, SimpleTest.finish);
+    return;
+  }
+
+  const { desc, url } = TEST_CASES[gCurrentTestCase];
+  info("Testing site with " + desc);
+
+  const iframe = document.querySelector("iframe").contentWindow;
+  iframe.wrappedJSObject.makeXhrCallback("GET", url);
+}
+
+function onNetworkEventUpdate(aState, aPacket)
+{
+  function onSecurityInfo(packet) {
+    const data = TEST_CASES[gCurrentTestCase];
+    is(packet.securityInfo.hsts, data.usesHSTS,
+      "Strict Transport Security detected correctly.");
+
+    runNextCase(aState);
+  }
+
+  if (aPacket.updateType === "securityInfo") {
+    aState.webConsoleFront.getSecurityInfo(aPacket.from, onSecurityInfo);
+  }
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html b/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html
new file mode 100644
index 0000000000..594dee904f
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_nsiconsolemessage.html
@@ -0,0 +1,74 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for nsIConsoleMessages</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Make sure that nsIConsoleMessages are logged. See bug 859756.</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+SimpleTest.waitForExplicitFinish();
+
+let expectedMessages = [];
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+  const {state} = await attachConsole(["PageError"]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  onLogMessage = onLogMessage.bind(null, aState);
+  aState.webConsoleFront.on("logMessage", onLogMessage);
+
+  expectedMessages = [{
+    message: "hello world! bug859756",
+    timeStamp: /^\d+$/,
+  }];
+
+  Services.console.logStringMessage("hello world! bug859756");
+
+  info("waiting for messages");
+}
+
+const receivedMessages = [];
+
+function onLogMessage(aState, aPacket)
+{
+  info("received message: " + aPacket.message);
+
+  let found = false;
+  for (const expected of expectedMessages) {
+    if (expected.message == aPacket.message) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    return;
+  }
+
+  receivedMessages.push(aPacket);
+  if (receivedMessages.length != expectedMessages.length) {
+    return;
+  }
+
+  aState.webConsoleFront.off("logMessage", onLogMessage);
+
+  checkObject(receivedMessages, expectedMessages);
+
+  closeDebugger(aState, () => SimpleTest.finish());
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor.html b/devtools/shared/webconsole/test/chrome/test_object_actor.html
new file mode 100644
index 0000000000..64879f172c
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_object_actor.html
@@ -0,0 +1,159 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the object actor</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the object actor</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+SpecialPowers.pushPrefEnv({
+  "set":  [["security.allow_eval_with_system_principal", true]]
+});
+
+async function startTest() {
+  removeEventListener("load", startTest);
+
+  const longString = (new Array(DevToolsServer.LONG_STRING_LENGTH + 3)).join("\u0629");
+  createTestGlobalVariable(longString);
+
+  const {state} = await attachConsoleToTab(["ConsoleAPI"]);
+  const onConsoleApiCall = state.webConsoleFront.once("consoleAPICall");
+  top.console.log("hello", top.wrappedJSObject.foobarObject);
+  const {message} = await onConsoleApiCall;
+
+  info("checking the console API call packet");
+  checkConsoleAPICall(message, {
+    level: "log",
+    filename: /test_object_actor/,
+    functionName: "startTest",
+    arguments: ["hello", {
+      type: "object",
+      actor: /[a-z]/,
+    }],
+  });
+
+  info("inspecting object properties");
+  const {ownProperties} = await message.arguments[1].getPrototypeAndProperties();
+
+  const expectedProps = {
+    "abArray": {
+      value: {
+        type: "object",
+        class: "Array",
+        actor: /[a-z]/,
+      },
+    },
+    "foo": {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: 1,
+    },
+    "foobar": {
+      value: "hello",
+    },
+    "foobaz": {
+      value: {
+        type: "object",
+        class: "HTMLDocument",
+        actor: /[a-z]/,
+      },
+    },
+    "getterAndSetter": {
+      get: {
+        type: "object",
+        class: "Function",
+        actor: /[a-z]/,
+      },
+      set: {
+        type: "object",
+        class: "Function",
+        actor: /[a-z]/,
+      },
+    },
+    "longStringObj": {
+      value: {
+        type: "object",
+        class: "Object",
+        actor: /[a-z]/,
+      },
+    },
+    "notInspectable": {
+      value: {
+        type: "object",
+        class: "Object",
+        actor: /[a-z]/,
+      },
+    },
+    "omg": {
+      value: { type: "null" },
+    },
+    "omgfn": {
+      value: {
+        type: "object",
+        class: "Function",
+        actor: /[a-z]/,
+      },
+    },
+    "tamarbuta": {
+      value: {
+        type: "longString",
+        initial: longString.substring(0,
+          DevToolsServer.LONG_STRING_INITIAL_LENGTH),
+        length: longString.length,
+      },
+    },
+    "testfoo": {
+      value: false,
+    },
+  };
+  is(Object.keys(ownProperties).length, Object.keys(expectedProps).length,
+     "number of enumerable properties");
+  checkObject(ownProperties, expectedProps);
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+}
+
+
+function createTestGlobalVariable(longString) {
+  // Here we put the objects in the correct window, to avoid having them all
+  // wrapped by proxies for cross-compartment access.
+  const foobarObject = top.Object.create(null);
+  foobarObject.tamarbuta = longString;
+  foobarObject.foo = 1;
+  foobarObject.foobar = "hello";
+  foobarObject.omg = null;
+  foobarObject.testfoo = false;
+  foobarObject.notInspectable = top.Object.create(null);
+  foobarObject.omgfn = new top.Function("return 'myResult'");
+  foobarObject.abArray = new top.Array("a", "b");
+  foobarObject.foobaz = top.document;
+
+  top.Object.defineProperty(foobarObject, "getterAndSetter", {
+    enumerable: true,
+    get: new top.Function("return 'foo';"),
+    set: new top.Function("1+2"),
+  });
+
+  foobarObject.longStringObj = top.Object.create(null);
+  foobarObject.longStringObj.toSource = new top.Function("'" + longString + "'");
+  foobarObject.longStringObj.toString = new top.Function("'" + longString + "'");
+  foobarObject.longStringObj.boom = "explode";
+  top.wrappedJSObject.foobarObject = foobarObject;
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html
new file mode 100644
index 0000000000..d066ff5bf1
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters.html
@@ -0,0 +1,76 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for the native getters in object actors</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the native getters in object actors</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest() {
+  removeEventListener("load", startTest);
+  const {state} = await attachConsoleToTab(["ConsoleAPI"]);
+
+  const onConsoleAPICall = state.webConsoleFront.once("consoleAPICall");
+  top.console.log("hello", document);
+  const {message} = await onConsoleAPICall;
+
+  info("checking the console API call packet");
+  checkConsoleAPICall(message, {
+    level: "log",
+    filename: /test_object_actor/,
+    functionName: "startTest",
+    arguments: ["hello", {
+      type: "object",
+      actor: /[a-z]/,
+    }],
+  });
+
+  info("inspecting object properties");
+  const args = message.arguments;
+  const {ownProperties, safeGetterValues} = await args[1].getPrototypeAndProperties();
+
+  const expectedProps = {
+    "location": {
+      get: {
+        type: "object",
+        class: "Function",
+        actor: /[a-z]/,
+      },
+    },
+  };
+  ok(Object.keys(ownProperties).length >= Object.keys(expectedProps).length, 
+    "number of properties");
+
+  info("check ownProperties");
+  checkObject(ownProperties, expectedProps);
+
+  info("check safeGetterValues");
+  checkObject(safeGetterValues, {
+    "title": {
+      getterValue: /native getters in object actors/,
+      getterPrototypeLevel: 2,
+    },
+    "styleSheets": {
+      getterValue: /Front for obj\//,
+      getterPrototypeLevel: 2,
+    },
+  });
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html
new file mode 100644
index 0000000000..eba977349f
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_object_actor_native_getters_lenient_this.html
@@ -0,0 +1,55 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test that WebIDL attributes with the LenientThis extended attribute
+         do not appear in the wrong objects</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for the native getters in object actors</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest() {
+  removeEventListener("load", startTest);
+  const {state} = await attachConsoleToTab(["ConsoleAPI"]);
+
+  const onConsoleApiCall = state.webConsoleFront.once("consoleAPICall");
+  const docAsProto = Object.create(document);
+  top.console.log("hello", docAsProto);
+  const {message} = await onConsoleApiCall;
+
+  info("checking the console API call packet");
+  checkConsoleAPICall(message, {
+    level: "log",
+    filename: /test_object_actor/,
+    functionName: "startTest",
+    arguments: ["hello", {
+      type: "object",
+      actor: /[a-z]/,
+    }],
+  });
+
+  info("inspecting object properties");
+  const args = message.arguments;
+
+  const {ownProperties, safeGetterValues} = await args[1].getPrototypeAndProperties();
+
+  is(Object.keys(ownProperties).length, 0, "number of properties");
+  is(Object.keys(safeGetterValues).length, 0, "number of safe getters");
+
+  await closeDebugger(state);
+  SimpleTest.finish();
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_page_errors.html b/devtools/shared/webconsole/test/chrome/test_page_errors.html
new file mode 100644
index 0000000000..c0f6b4dfff
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_page_errors.html
@@ -0,0 +1,224 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Test for page errors</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Test for page errors</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+const { MESSAGE_CATEGORY } = require("devtools/shared/constants");
+SimpleTest.waitForExplicitFinish();
+
+const previousEnabled = window.docShell.cssErrorReportingEnabled;
+window.docShell.cssErrorReportingEnabled = true;
+
+SimpleTest.registerCleanupFunction(() => {
+  window.docShell.cssErrorReportingEnabled = previousEnabled;
+});
+
+let expectedPageErrors = [];
+
+const NO_UNCAUGHT_EXCEPTION = Symbol();
+
+function doPageErrors() {
+  expectedPageErrors = {
+    "document.body.style.color = 'fooColor';": {
+      errorMessage: /fooColor/,
+      sourceName: /test_page_errors/,
+      category: MESSAGE_CATEGORY.CSS_PARSER,
+      timeStamp: /^\d+$/,
+      error: false,
+      warning: true,
+    },
+   "document.doTheImpossible();": {
+      errorMessage: /doTheImpossible/,
+      errorMessageName: undefined,
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    "(42).toString(0);": {
+      errorMessage: /radix/,
+      errorMessageName: "JSMSG_BAD_RADIX",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+     "'use strict'; (Object.freeze({name: 'Elsa', score: 157})).score = 0;": {
+      errorMessage: /read.only/,
+      errorMessageName: "JSMSG_READ_ONLY",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+     "([]).length = -1": {
+      errorMessage: /array length/,
+      errorMessageName: "JSMSG_BAD_ARRAY_LENGTH",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+     "'abc'.repeat(-1);": {
+      errorMessage: /repeat count.*non-negative/,
+      errorMessageName: "JSMSG_NEGATIVE_REPETITION_COUNT",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    "'a'.repeat(2e28);": {
+      errorMessage: /repeat count.*less than infinity/,
+      errorMessageName: "JSMSG_RESULTING_STRING_TOO_LARGE",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    "77.1234.toExponential(-1);": {
+      errorMessage: /out of range/,
+      errorMessageName: "JSMSG_PRECISION_RANGE",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    "function a() { return; 1 + 1; }": {
+      errorMessage: /unreachable code/,
+      errorMessageName: "JSMSG_STMT_AFTER_RETURN",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: false,
+      warning: true,
+    },
+    "let a, a;": {
+      errorMessage: /redeclaration of/,
+      errorMessageName: "JSMSG_REDECLARED_VAR",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+      notes: [
+        {
+          messageBody: /Previously declared at line/,
+          frame: {
+            source: /test_page_errors/,
+          }
+        }
+      ]
+    },
+    [`let error = new TypeError("abc");
+      error.name = "MyError";
+      error.message = "here";
+      throw error`]: {
+      errorMessage: /MyError: here/,
+      errorMessageName: "",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    "DOMTokenList.prototype.contains.call([])": {
+      errorMessage: /does not implement interface/,
+      errorMessageName: "MSG_METHOD_THIS_DOES_NOT_IMPLEMENT_INTERFACE",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+    },
+    [`let error2 = new TypeError("abc");
+      error2.name = "MyPromiseError";
+      error2.message = "here2";
+      Promise.reject(error2)`]: {
+      errorMessage: /MyPromiseError: here2/,
+      errorMessageName: "",
+      sourceName: /test_page_errors/,
+      category: "chrome javascript",
+      timeStamp: /^\d+$/,
+      error: true,
+      warning: false,
+      // Promise.reject doesn't produce an uncaught exception
+      // even though |exception: true|.
+      [NO_UNCAUGHT_EXCEPTION]: true
+    }
+  };
+
+  let container = document.createElement("script");
+  for (const stmt of Object.keys(expectedPageErrors)) {
+      if (expectedPageErrors[stmt].error &&
+          !expectedPageErrors[stmt][NO_UNCAUGHT_EXCEPTION]) {
+          SimpleTest.expectUncaughtException();
+      }
+      info("starting stmt: " + stmt);
+      container = document.createElement("script");
+      document.body.appendChild(container);
+      container.textContent = stmt;
+      document.body.removeChild(container);
+      info("ending stmt: " + stmt);
+  }
+}
+
+async function startTest() {
+  removeEventListener("load", startTest);
+
+  const {state} = await attachConsole(["PageError"]);
+  onAttach(state);
+}
+
+function onAttach(state) {
+  onPageError = onPageError.bind(null, state);
+  state.webConsoleFront.on("pageError", onPageError);
+  doPageErrors();
+}
+
+const pageErrors = [];
+
+function onPageError(state, packet) {
+  if (!packet.pageError.sourceName.includes("test_page_errors")) {
+    info("Ignoring error from unknown source: " + packet.pageError.sourceName);
+    return;
+  }
+
+  pageErrors.push(packet.pageError);
+  if (pageErrors.length != Object.keys(expectedPageErrors).length) {
+    return;
+  }
+
+  state.webConsoleFront.off("pageError", onPageError);
+
+  Object.values(expectedPageErrors).forEach(function(message, index) {
+    info("checking received page error #" + index);
+    checkObject(pageErrors[index], Object.values(expectedPageErrors)[index]);
+  });
+
+  closeDebugger(state, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>
diff --git a/devtools/shared/webconsole/test/chrome/test_throw.html b/devtools/shared/webconsole/test/chrome/test_throw.html
new file mode 100644
index 0000000000..123519174a
--- /dev/null
+++ b/devtools/shared/webconsole/test/chrome/test_throw.html
@@ -0,0 +1,92 @@
+<!DOCTYPE HTML>
+<html lang="en">
+<head>
+  <meta charset="utf8">
+  <title>Web Console throw tests</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="common.js"></script>
+  <!-- Any copyright is dedicated to the Public Domain.
+     - http://creativecommons.org/publicdomain/zero/1.0/ -->
+</head>
+<body>
+<p>Web Console throw tests</p>
+
+<script class="testbody" type="text/javascript">
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+async function startTest()
+{
+  removeEventListener("load", startTest);
+  const {state} = await attachConsoleToTab([]);
+  onAttach(state);
+}
+
+function onAttach(aState)
+{
+  const tests = [];
+
+  const falsyValues = ["-0", "null", "undefined", "Infinity", "-Infinity", "NaN"];
+  falsyValues.forEach(function(value) {
+    tests.push(async function() {
+      const response = await aState.webConsoleFront.evaluateJSAsync("throw " + value + ";")
+      const type = response.exception.type;
+      is(type, value, "exception.type for throw " + value);
+      nextTest();
+    });
+  });
+
+  const identityTestValues = [false, 0];
+  identityTestValues.forEach(function(value) {
+    tests.push(async function() {
+      const response = await aState.webConsoleFront.evaluateJSAsync("throw " + value + ";")
+      const exception = response.exception;
+      is(exception, value, "response.exception for throw " + value);
+      nextTest();
+    });
+  });
+
+  const longString = Array(DevToolsServer.LONG_STRING_LENGTH + 1).join("a"),
+      shortedString = longString.substring(0,
+                        DevToolsServer.LONG_STRING_INITIAL_LENGTH
+                      );
+  tests.push(async function() {
+    const response = await aState.webConsoleFront.evaluateJSAsync("throw '" + longString + "';")
+    is(response.exception.initial, shortedString,
+      "exception.initial for throw longString"
+    );
+    is(response.exceptionMessage.initial, shortedString,
+      "exceptionMessage.initial for throw longString"
+    );
+    nextTest();
+  });
+
+  const symbolTestValues = [
+    ["Symbol.iterator", "Symbol(Symbol.iterator)"],
+    ["Symbol('foo')", "Symbol(foo)"],
+    ["Symbol()", "Symbol()"],
+  ];
+  symbolTestValues.forEach(function([expr, message]) {
+    tests.push(async function() {
+      const response = await aState.webConsoleFront.evaluateJSAsync("throw " + expr + ";");
+      is(response.exceptionMessage, message,
+         "response.exception for throw " + expr);
+      nextTest();
+    });
+  });
+
+  runTests(tests, endTest.bind(null, aState));
+}
+
+function endTest(aState)
+{
+  closeDebugger(aState, function() {
+    SimpleTest.finish();
+  });
+}
+
+addEventListener("load", startTest);
+</script>
+</body>
+</html>