Adding upstream version 124.0.1.upstream/124.0.1

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

175 files changed, 9095 insertions, 0 deletions

diff --git a/docshell/test/browser/Bug1622420Child.sys.mjs b/docshell/test/browser/Bug1622420Child.sys.mjs
new file mode 100644
index 0000000000..c5520d5943
--- /dev/null
+++ b/docshell/test/browser/Bug1622420Child.sys.mjs
@@ -0,0 +1,9 @@
+export class Bug1622420Child extends JSWindowActorChild {
+  receiveMessage(msg) {
+    switch (msg.name) {
+      case "hasWindowContextForTopBC":
+        return !!this.browsingContext.top.currentWindowContext;
+    }
+    return null;
+  }
+}
diff --git a/docshell/test/browser/Bug422543Child.sys.mjs b/docshell/test/browser/Bug422543Child.sys.mjs
new file mode 100644
index 0000000000..524ac33ffd
--- /dev/null
+++ b/docshell/test/browser/Bug422543Child.sys.mjs
@@ -0,0 +1,98 @@
+class SHistoryListener {
+  constructor() {
+    this.retval = true;
+    this.last = "initial";
+  }
+
+  OnHistoryNewEntry(aNewURI) {
+    this.last = "newentry";
+  }
+
+  OnHistoryGotoIndex() {
+    this.last = "gotoindex";
+  }
+
+  OnHistoryPurge() {
+    this.last = "purge";
+  }
+
+  OnHistoryReload() {
+    this.last = "reload";
+    return this.retval;
+  }
+
+  OnHistoryReplaceEntry() {}
+}
+SHistoryListener.prototype.QueryInterface = ChromeUtils.generateQI([
+  "nsISHistoryListener",
+  "nsISupportsWeakReference",
+]);
+
+let listeners;
+
+export class Bug422543Child extends JSWindowActorChild {
+  constructor() {
+    super();
+  }
+
+  actorCreated() {
+    if (listeners) {
+      return;
+    }
+
+    this.shistory = this.docShell.nsIWebNavigation.sessionHistory;
+    listeners = [new SHistoryListener(), new SHistoryListener()];
+
+    for (let listener of listeners) {
+      this.shistory.legacySHistory.addSHistoryListener(listener);
+    }
+  }
+
+  cleanup() {
+    for (let listener of listeners) {
+      this.shistory.legacySHistory.removeSHistoryListener(listener);
+    }
+    this.shistory = null;
+    listeners = null;
+    return {};
+  }
+
+  getListenerStatus() {
+    return listeners.map(l => l.last);
+  }
+
+  resetListeners() {
+    for (let listener of listeners) {
+      listener.last = "initial";
+    }
+
+    return {};
+  }
+
+  notifyReload() {
+    let history = this.shistory.legacySHistory;
+    let rval = history.notifyOnHistoryReload();
+    return { rval };
+  }
+
+  setRetval({ num, val }) {
+    listeners[num].retval = val;
+    return {};
+  }
+
+  receiveMessage(msg) {
+    switch (msg.name) {
+      case "cleanup":
+        return this.cleanup();
+      case "getListenerStatus":
+        return this.getListenerStatus();
+      case "notifyReload":
+        return this.notifyReload();
+      case "resetListeners":
+        return this.resetListeners();
+      case "setRetval":
+        return this.setRetval(msg.data);
+    }
+    return null;
+  }
+}
diff --git a/docshell/test/browser/browser.toml b/docshell/test/browser/browser.toml
new file mode 100644
index 0000000000..bcda46fd2e
--- /dev/null
+++ b/docshell/test/browser/browser.toml
@@ -0,0 +1,326 @@
+[DEFAULT]
+support-files = [
+  "Bug422543Child.sys.mjs",
+  "dummy_page.html",
+  "favicon_bug655270.ico",
+  "file_bug234628-1-child.html",
+  "file_bug234628-1.html",
+  "file_bug234628-10-child.xhtml",
+  "file_bug234628-10.html",
+  "file_bug234628-11-child.xhtml",
+  "file_bug234628-11-child.xhtml^headers^",
+  "file_bug234628-11.html",
+  "file_bug234628-2-child.html",
+  "file_bug234628-2.html",
+  "file_bug234628-3-child.html",
+  "file_bug234628-3.html",
+  "file_bug234628-4-child.html",
+  "file_bug234628-4.html",
+  "file_bug234628-5-child.html",
+  "file_bug234628-5.html",
+  "file_bug234628-6-child.html",
+  "file_bug234628-6-child.html^headers^",
+  "file_bug234628-6.html",
+  "file_bug234628-8-child.html",
+  "file_bug234628-8.html",
+  "file_bug234628-9-child.html",
+  "file_bug234628-9.html",
+  "file_bug420605.html",
+  "file_bug503832.html",
+  "file_bug655270.html",
+  "file_bug670318.html",
+  "file_bug673087-1.html",
+  "file_bug673087-1.html^headers^",
+  "file_bug673087-1-child.html",
+  "file_bug673087-2.html",
+  "file_bug852909.pdf",
+  "file_bug852909.png",
+  "file_bug1046022.html",
+  "file_bug1206879.html",
+  "file_bug1328501.html",
+  "file_bug1328501_frame.html",
+  "file_bug1328501_framescript.js",
+  "file_bug1543077-3-child.html",
+  "file_bug1543077-3.html",
+  "file_multiple_pushState.html",
+  "file_onbeforeunload_0.html",
+  "file_onbeforeunload_1.html",
+  "file_onbeforeunload_2.html",
+  "file_onbeforeunload_3.html",
+  "print_postdata.sjs",
+  "test-form_sjis.html",
+  "head.js",
+  "file_data_load_inherit_csp.html",
+  "file_click_link_within_view_source.html",
+  "onload_message.html",
+  "onpageshow_message.html",
+  "file_cross_process_csp_inheritance.html",
+  "file_open_about_blank.html",
+  "file_slow_load.sjs",
+  "file_bug1648464-1.html",
+  "file_bug1648464-1-child.html",
+  "file_bug1688368-1.sjs",
+  "file_bug1691153.html",
+  "file_bug1716290-1.sjs",
+  "file_bug1716290-2.sjs",
+  "file_bug1716290-3.sjs",
+  "file_bug1716290-4.sjs",
+  "file_bug1736248-1.html",
+]
+
+["browser_alternate_fixup_middle_click_link.js"]
+https_first_disabled = true
+
+["browser_backforward_restore_scroll.js"]
+https_first_disabled = true
+support-files = [
+  "file_backforward_restore_scroll.html",
+  "file_backforward_restore_scroll.html^headers^",
+]
+
+["browser_backforward_userinteraction.js"]
+support-files = ["dummy_iframe_page.html"]
+skip-if = ["os == 'linux' && bits == 64 && !debug"] # Bug 1607713
+
+["browser_backforward_userinteraction_about.js"]
+
+["browser_backforward_userinteraction_systemprincipal.js"]
+
+["browser_badCertDomainFixup.js"]
+
+["browser_bfcache_copycommand.js"]
+skip-if = ["os == 'linux' && bits == 64"] # Bug 1730593
+
+["browser_browsingContext-01.js"]
+https_first_disabled = true
+
+["browser_browsingContext-02.js"]
+https_first_disabled = true
+
+["browser_browsingContext-embedder.js"]
+
+["browser_browsingContext-getAllBrowsingContextsInSubtree.js"]
+
+["browser_browsingContext-getWindowByName.js"]
+
+["browser_browsingContext-webProgress.js"]
+skip-if = ["os == 'linux' && bits == 64 && !debug"] # Bug 1721261
+https_first_disabled = true
+
+["browser_browsing_context_attached.js"]
+https_first_disabled = true
+
+["browser_browsing_context_discarded.js"]
+https_first_disabled = true
+
+["browser_bug92473.js"]
+
+["browser_bug134911.js"]
+
+["browser_bug234628-1.js"]
+
+["browser_bug234628-10.js"]
+
+["browser_bug234628-11.js"]
+
+["browser_bug234628-2.js"]
+
+["browser_bug234628-3.js"]
+
+["browser_bug234628-4.js"]
+
+["browser_bug234628-5.js"]
+
+["browser_bug234628-6.js"]
+
+["browser_bug234628-8.js"]
+
+["browser_bug234628-9.js"]
+
+["browser_bug349769.js"]
+
+["browser_bug388121-1.js"]
+
+["browser_bug388121-2.js"]
+
+["browser_bug420605.js"]
+skip-if = ["verify"]
+
+["browser_bug422543.js"]
+https_first_disabled = true
+
+["browser_bug441169.js"]
+
+["browser_bug503832.js"]
+skip-if = ["verify"]
+
+["browser_bug554155.js"]
+
+["browser_bug655270.js"]
+
+["browser_bug655273.js"]
+
+["browser_bug670318.js"]
+skip-if = ["os == 'linux' && (debug || asan || tsan)"]  # Bug 1717403
+
+["browser_bug673087-1.js"]
+
+["browser_bug673087-2.js"]
+
+["browser_bug673467.js"]
+
+["browser_bug852909.js"]
+skip-if = ["verify && debug && os == 'win'"]
+
+["browser_bug1206879.js"]
+https_first_disabled = true
+
+["browser_bug1309900_crossProcessHistoryNavigation.js"]
+https_first_disabled = true
+
+["browser_bug1328501.js"]
+https_first_disabled = true
+
+["browser_bug1347823.js"]
+
+["browser_bug1415918_beforeunload_options.js"]
+https_first_disabled = true
+
+["browser_bug1543077-3.js"]
+
+["browser_bug1594938.js"]
+
+["browser_bug1622420.js"]
+support-files = [
+  "file_bug1622420.html",
+  "Bug1622420Child.sys.mjs",
+]
+
+["browser_bug1648464-1.js"]
+
+["browser_bug1673702.js"]
+https_first_disabled = true
+skip-if = [
+  "os == 'linux' && bits == 64 && os_version == '18.04' && debug", # Bug 1674513
+  "os == 'win'", # Bug 1674513
+]
+support-files = [
+  "file_bug1673702.json",
+  "file_bug1673702.json^headers^",
+]
+
+["browser_bug1674464.js"]
+https_first_disabled = true
+skip-if = [
+  "!fission",
+  "!crashreporter", # On a crash we only keep history when fission is enabled.
+]
+
+["browser_bug1688368-1.js"]
+
+["browser_bug1691153.js"]
+https_first_disabled = true
+
+["browser_bug1705872.js"]
+
+["browser_bug1716290-1.js"]
+
+["browser_bug1716290-2.js"]
+
+["browser_bug1716290-3.js"]
+
+["browser_bug1716290-4.js"]
+
+["browser_bug1719178.js"]
+
+["browser_bug1736248-1.js"]
+
+["browser_bug1757005.js"]
+
+["browser_bug1769189.js"]
+
+["browser_bug1798780.js"]
+
+["browser_click_link_within_view_source.js"]
+
+["browser_cross_process_csp_inheritance.js"]
+https_first_disabled = true
+
+["browser_csp_sandbox_no_script_js_uri.js"]
+support-files = [
+  "file_csp_sandbox_no_script_js_uri.html",
+  "file_csp_sandbox_no_script_js_uri.html^headers^",
+]
+
+["browser_csp_uir.js"]
+support-files = [
+  "file_csp_uir.html",
+  "file_csp_uir_dummy.html",
+]
+
+["browser_dataURI_unique_opaque_origin.js"]
+https_first_disabled = true
+
+["browser_data_load_inherit_csp.js"]
+
+["browser_fall_back_to_https.js"]
+https_first_disabled = true
+skip-if = ["os == 'mac'"]
+
+["browser_frameloader_swap_with_bfcache.js"]
+
+["browser_history_triggeringprincipal_viewsource.js"]
+https_first_disabled = true
+
+["browser_isInitialDocument.js"]
+https_first_disabled = true
+
+["browser_loadURI_postdata.js"]
+
+["browser_multiple_pushState.js"]
+https_first_disabled = true
+
+["browser_onbeforeunload_frame.js"]
+support-files = ["head_browser_onbeforeunload.js"]
+
+["browser_onbeforeunload_navigation.js"]
+skip-if = ["os == 'win' && !debug"] # bug 1300351
+
+["browser_onbeforeunload_parent.js"]
+support-files = ["head_browser_onbeforeunload.js"]
+
+["browser_onunload_stop.js"]
+https_first_disabled = true
+
+["browser_overlink.js"]
+support-files = ["overlink_test.html"]
+
+["browser_platform_emulation.js"]
+
+["browser_search_notification.js"]
+
+["browser_tab_replace_while_loading.js"]
+skip-if = [
+  "os == 'linux' && bits == 64 && os_version == '18.04'", # Bug 1604237
+  "os == 'win'", # Bug 1671794
+]
+
+["browser_tab_touch_events.js"]
+
+["browser_targetTopLevelLinkClicksToBlank.js"]
+
+["browser_title_in_session_history.js"]
+skip-if = ["!sessionHistoryInParent"]
+
+["browser_ua_emulation.js"]
+
+["browser_uriFixupAlternateRedirects.js"]
+https_first_disabled = true
+support-files = ["redirect_to_example.sjs"]
+
+["browser_uriFixupIntegration.js"]
+
+["browser_viewsource_chrome_to_content.js"]
+
+["browser_viewsource_multipart.js"]
+support-files = ["file_basic_multipart.sjs"]
diff --git a/docshell/test/browser/browser_alternate_fixup_middle_click_link.js b/docshell/test/browser/browser_alternate_fixup_middle_click_link.js
new file mode 100644
index 0000000000..dcf2d80af9
--- /dev/null
+++ b/docshell/test/browser/browser_alternate_fixup_middle_click_link.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Check that we don't do alternate fixup when users middle-click
+ * broken links in the content document.
+ */
+add_task(async function test_alt_fixup_middle_click() {
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    await SpecialPowers.spawn(browser, [], () => {
+      let link = content.document.createElement("a");
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+      link.href = "http://example/foo";
+      link.textContent = "Me, me, click me!";
+      content.document.body.append(link);
+    });
+    let newTabPromise = BrowserTestUtils.waitForNewTab(
+      gBrowser,
+      /* wantLoad = */ null,
+      /* waitForLoad = */ true,
+      /* waitForAnyTab = */ false,
+      /* maybeErrorPage = */ true
+    );
+    await BrowserTestUtils.synthesizeMouseAtCenter(
+      "a[href]",
+      { button: 1 },
+      browser
+    );
+    let tab = await newTabPromise;
+    let { browsingContext } = tab.linkedBrowser;
+    // TBH, if the test fails, we probably force-crash because we try to reach
+    // *www.* example.com, which isn't proxied by the test infrastructure so
+    // will forcibly abort the test. But we need some asserts so they might as
+    // well be meaningful:
+    is(
+      tab.linkedBrowser.currentURI.spec,
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+      "http://example/foo",
+      "URL for tab should be correct."
+    );
+
+    ok(
+      browsingContext.currentWindowGlobal.documentURI.spec.startsWith(
+        "about:neterror"
+      ),
+      "Should be showing error page."
+    );
+    BrowserTestUtils.removeTab(tab);
+  });
+});
diff --git a/docshell/test/browser/browser_backforward_restore_scroll.js b/docshell/test/browser/browser_backforward_restore_scroll.js
new file mode 100644
index 0000000000..ca687bf528
--- /dev/null
+++ b/docshell/test/browser/browser_backforward_restore_scroll.js
@@ -0,0 +1,54 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const ROOT = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "http://mochi.test:8888"
+);
+const URL1 = ROOT + "file_backforward_restore_scroll.html";
+// eslint-disable-next-line @microsoft/sdl/no-insecure-url
+const URL2 = "http://example.net/";
+
+const SCROLL0 = 500;
+const SCROLL1 = 1000;
+
+function promiseBrowserLoaded(url) {
+  return BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, false, url);
+}
+
+add_task(async function test() {
+  await BrowserTestUtils.openNewForegroundTab(gBrowser, URL1);
+
+  // Scroll the 2 frames.
+  let children = gBrowser.selectedBrowser.browsingContext.children;
+  await SpecialPowers.spawn(children[0], [SCROLL0], scrollY =>
+    content.scrollTo(0, scrollY)
+  );
+  await SpecialPowers.spawn(children[1], [SCROLL1], scrollY =>
+    content.scrollTo(0, scrollY)
+  );
+
+  // Navigate forwards then backwards.
+  let loaded = promiseBrowserLoaded(URL2);
+  BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, URL2);
+  await loaded;
+
+  loaded = promiseBrowserLoaded(URL1);
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => {
+    content.history.back();
+  });
+  await loaded;
+
+  // And check the results.
+  children = gBrowser.selectedBrowser.browsingContext.children;
+  await SpecialPowers.spawn(children[0], [SCROLL0], scrollY => {
+    Assert.equal(content.scrollY, scrollY, "frame 0 has correct scroll");
+  });
+  await SpecialPowers.spawn(children[1], [SCROLL1], scrollY => {
+    Assert.equal(content.scrollY, scrollY, "frame 1 has correct scroll");
+  });
+
+  gBrowser.removeTab(gBrowser.selectedTab);
+});
diff --git a/docshell/test/browser/browser_backforward_userinteraction.js b/docshell/test/browser/browser_backforward_userinteraction.js
new file mode 100644
index 0000000000..264299c902
--- /dev/null
+++ b/docshell/test/browser/browser_backforward_userinteraction.js
@@ -0,0 +1,374 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "https://example.com"
+  ) + "dummy_page.html";
+const IFRAME_PAGE =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "https://example.com"
+  ) + "dummy_iframe_page.html";
+
+async function assertMenulist(entries, baseURL = TEST_PAGE) {
+  // Wait for the session data to be flushed before continuing the test
+  await new Promise(resolve =>
+    SessionStore.getSessionHistory(gBrowser.selectedTab, resolve)
+  );
+
+  let backButton = document.getElementById("back-button");
+  let contextMenu = document.getElementById("backForwardMenu");
+
+  info("waiting for the history menu to open");
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    contextMenu,
+    "popupshown"
+  );
+  EventUtils.synthesizeMouseAtCenter(backButton, {
+    type: "contextmenu",
+    button: 2,
+  });
+  await popupShownPromise;
+
+  ok(true, "history menu opened");
+
+  let nodes = contextMenu.childNodes;
+
+  is(
+    nodes.length,
+    entries.length,
+    "Has the expected number of contextMenu entries"
+  );
+
+  for (let i = 0; i < entries.length; i++) {
+    let node = nodes[i];
+    is(
+      node.getAttribute("uri").replace(/[?|#]/, "!"),
+      baseURL + "!entry=" + entries[i],
+      "contextMenu node has the correct uri"
+    );
+  }
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    contextMenu,
+    "popuphidden"
+  );
+  contextMenu.hidePopup();
+  await popupHiddenPromise;
+}
+
+// There are different ways of loading a page, but they should exhibit roughly the same
+// back-forward behavior for the purpose of requiring user interaction. Thus, we
+// have a utility function that runs the same test with a parameterized method of loading
+// new URLs.
+async function runTopLevelTest(loadMethod, useHashes = false) {
+  let p = useHashes ? "#" : "?";
+
+  // Test with both pref on and off
+  for (let requireUserInteraction of [true, false]) {
+    Services.prefs.setBoolPref(
+      "browser.navigation.requireUserInteraction",
+      requireUserInteraction
+    );
+
+    let tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      TEST_PAGE + p + "entry=0"
+    );
+    let browser = tab.linkedBrowser;
+
+    assertBackForwardState(false, false);
+
+    await loadMethod(TEST_PAGE + p + "entry=1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist([1, 0]);
+
+    await loadMethod(TEST_PAGE + p + "entry=2");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(requireUserInteraction ? [2, 0] : [2, 1, 0]);
+
+    await loadMethod(TEST_PAGE + p + "entry=3");
+
+    info("Adding user interaction for entry=3");
+    // Add some user interaction to entry 3
+    await BrowserTestUtils.synthesizeMouse(
+      "body",
+      0,
+      0,
+      {},
+      browser.browsingContext,
+      true
+    );
+
+    assertBackForwardState(true, false);
+    await assertMenulist(requireUserInteraction ? [3, 0] : [3, 2, 1, 0]);
+
+    await loadMethod(TEST_PAGE + p + "entry=4");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(requireUserInteraction ? [4, 3, 0] : [4, 3, 2, 1, 0]);
+
+    info("Adding user interaction for entry=4");
+    // Add some user interaction to entry 4
+    await BrowserTestUtils.synthesizeMouse(
+      "body",
+      0,
+      0,
+      {},
+      browser.browsingContext,
+      true
+    );
+
+    await loadMethod(TEST_PAGE + p + "entry=5");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [5, 4, 3, 0] : [5, 4, 3, 2, 1, 0]
+    );
+
+    await goBack(TEST_PAGE + p + "entry=4");
+    await goBack(TEST_PAGE + p + "entry=3");
+
+    if (!requireUserInteraction) {
+      await goBack(TEST_PAGE + p + "entry=2");
+      await goBack(TEST_PAGE + p + "entry=1");
+    }
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [5, 4, 3, 0] : [5, 4, 3, 2, 1, 0]
+    );
+
+    await goBack(TEST_PAGE + p + "entry=0");
+
+    assertBackForwardState(false, true);
+
+    if (!requireUserInteraction) {
+      await goForward(TEST_PAGE + p + "entry=1");
+      await goForward(TEST_PAGE + p + "entry=2");
+    }
+
+    await goForward(TEST_PAGE + p + "entry=3");
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [5, 4, 3, 0] : [5, 4, 3, 2, 1, 0]
+    );
+
+    await goForward(TEST_PAGE + p + "entry=4");
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [5, 4, 3, 0] : [5, 4, 3, 2, 1, 0]
+    );
+
+    await goForward(TEST_PAGE + p + "entry=5");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [5, 4, 3, 0] : [5, 4, 3, 2, 1, 0]
+    );
+
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  Services.prefs.clearUserPref("browser.navigation.requireUserInteraction");
+}
+
+async function runIframeTest(loadMethod) {
+  // Test with both pref on and off
+  for (let requireUserInteraction of [true, false]) {
+    Services.prefs.setBoolPref(
+      "browser.navigation.requireUserInteraction",
+      requireUserInteraction
+    );
+
+    // First test the boring case where we only have one iframe.
+    let tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      IFRAME_PAGE + "?entry=0"
+    );
+    let browser = tab.linkedBrowser;
+
+    assertBackForwardState(false, false);
+
+    await loadMethod(TEST_PAGE + "?sub_entry=1", "frame1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist([0, 0], IFRAME_PAGE);
+
+    await loadMethod(TEST_PAGE + "?sub_entry=2", "frame1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [0, 0] : [0, 0, 0],
+      IFRAME_PAGE
+    );
+
+    let bc = await SpecialPowers.spawn(browser, [], function () {
+      return content.document.getElementById("frame1").browsingContext;
+    });
+
+    // Add some user interaction to sub entry 2
+    await BrowserTestUtils.synthesizeMouse("body", 0, 0, {}, bc, true);
+
+    await loadMethod(TEST_PAGE + "?sub_entry=3", "frame1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [0, 0, 0] : [0, 0, 0, 0],
+      IFRAME_PAGE
+    );
+
+    await loadMethod(TEST_PAGE + "?sub_entry=4", "frame1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [0, 0, 0] : [0, 0, 0, 0, 0],
+      IFRAME_PAGE
+    );
+
+    if (!requireUserInteraction) {
+      await goBack(TEST_PAGE + "?sub_entry=3", true);
+    }
+
+    await goBack(TEST_PAGE + "?sub_entry=2", true);
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [0, 0, 0] : [0, 0, 0, 0, 0],
+      IFRAME_PAGE
+    );
+
+    await loadMethod(IFRAME_PAGE + "?entry=1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [1, 0, 0] : [1, 0, 0, 0],
+      IFRAME_PAGE
+    );
+
+    BrowserTestUtils.removeTab(tab);
+
+    // Two iframes, now we're talking.
+    tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      IFRAME_PAGE + "?entry=0"
+    );
+    browser = tab.linkedBrowser;
+
+    await loadMethod(IFRAME_PAGE + "?entry=1");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(requireUserInteraction ? [1, 0] : [1, 0], IFRAME_PAGE);
+
+    // Add some user interaction to frame 1.
+    bc = await SpecialPowers.spawn(browser, [], function () {
+      return content.document.getElementById("frame1").browsingContext;
+    });
+    await BrowserTestUtils.synthesizeMouse("body", 0, 0, {}, bc, true);
+
+    // Add some user interaction to frame 2.
+    bc = await SpecialPowers.spawn(browser, [], function () {
+      return content.document.getElementById("frame2").browsingContext;
+    });
+    await BrowserTestUtils.synthesizeMouse("body", 0, 0, {}, bc, true);
+
+    // Navigate frame 2.
+    await loadMethod(TEST_PAGE + "?sub_entry=1", "frame2");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [1, 1, 0] : [1, 1, 0],
+      IFRAME_PAGE
+    );
+
+    // Add some user interaction to frame 1, again.
+    bc = await SpecialPowers.spawn(browser, [], function () {
+      return content.document.getElementById("frame1").browsingContext;
+    });
+    await BrowserTestUtils.synthesizeMouse("body", 0, 0, {}, bc, true);
+
+    // Navigate frame 2, again.
+    await loadMethod(TEST_PAGE + "?sub_entry=2", "frame2");
+
+    assertBackForwardState(true, false);
+    await assertMenulist(
+      requireUserInteraction ? [1, 1, 1, 0] : [1, 1, 1, 0],
+      IFRAME_PAGE
+    );
+
+    await goBack(TEST_PAGE + "?sub_entry=1", true);
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [1, 1, 1, 0] : [1, 1, 1, 0],
+      IFRAME_PAGE
+    );
+
+    await goBack(TEST_PAGE + "?sub_entry=0", true);
+
+    assertBackForwardState(true, true);
+    await assertMenulist(
+      requireUserInteraction ? [1, 1, 1, 0] : [1, 1, 1, 0],
+      IFRAME_PAGE
+    );
+
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  Services.prefs.clearUserPref("browser.navigation.requireUserInteraction");
+}
+
+// Test that when the pref is flipped, we are skipping history
+// entries without user interaction when following links with hash URIs.
+add_task(async function test_hashURI() {
+  async function followLinkHash(url) {
+    info(`Creating and following a link to ${url}`);
+    let browser = gBrowser.selectedBrowser;
+    let loaded = BrowserTestUtils.waitForLocationChange(gBrowser, url);
+    await SpecialPowers.spawn(browser, [url], function (url) {
+      let a = content.document.createElement("a");
+      a.href = url;
+      content.document.body.appendChild(a);
+      a.click();
+    });
+    await loaded;
+    info(`Loaded ${url}`);
+  }
+
+  await runTopLevelTest(followLinkHash, true);
+});
+
+// Test that when the pref is flipped, we are skipping history
+// entries without user interaction when using history.pushState.
+add_task(async function test_pushState() {
+  await runTopLevelTest(pushState);
+});
+
+// Test that when the pref is flipped, we are skipping history
+// entries without user interaction when following a link.
+add_task(async function test_followLink() {
+  await runTopLevelTest(followLink);
+});
+
+// Test that when the pref is flipped, we are skipping history
+// entries without user interaction when navigating inside an iframe
+// using history.pushState.
+add_task(async function test_iframe_pushState() {
+  await runIframeTest(pushState);
+});
+
+// Test that when the pref is flipped, we are skipping history
+// entries without user interaction when navigating inside an iframe
+// by following links.
+add_task(async function test_iframe_followLink() {
+  await runIframeTest(followLink);
+});
diff --git a/docshell/test/browser/browser_backforward_userinteraction_about.js b/docshell/test/browser/browser_backforward_userinteraction_about.js
new file mode 100644
index 0000000000..606fcc45c5
--- /dev/null
+++ b/docshell/test/browser/browser_backforward_userinteraction_about.js
@@ -0,0 +1,67 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "https://example.com"
+  ) + "dummy_page.html";
+
+// Regression test for navigating back after visiting an about: page
+// loaded in the parent process.
+add_task(async function test_about_back() {
+  // Test with both pref on and off
+  for (let requireUserInteraction of [true, false]) {
+    Services.prefs.setBoolPref(
+      "browser.navigation.requireUserInteraction",
+      requireUserInteraction
+    );
+
+    let tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      TEST_PAGE + "?entry=0"
+    );
+    let browser = tab.linkedBrowser;
+    assertBackForwardState(false, false);
+
+    await followLink(TEST_PAGE + "?entry=1");
+    assertBackForwardState(true, false);
+
+    await followLink(TEST_PAGE + "?entry=2");
+    assertBackForwardState(true, false);
+
+    // Add some user interaction to entry 2
+    await BrowserTestUtils.synthesizeMouse("body", 0, 0, {}, browser, true);
+
+    await loadURI("about:config");
+    assertBackForwardState(true, false);
+
+    await goBack(TEST_PAGE + "?entry=2");
+    assertBackForwardState(true, true);
+
+    if (!requireUserInteraction) {
+      await goBack(TEST_PAGE + "?entry=1");
+      assertBackForwardState(true, true);
+    }
+
+    await goBack(TEST_PAGE + "?entry=0");
+    assertBackForwardState(false, true);
+
+    if (!requireUserInteraction) {
+      await goForward(TEST_PAGE + "?entry=1");
+      assertBackForwardState(true, true);
+    }
+
+    await goForward(TEST_PAGE + "?entry=2");
+    assertBackForwardState(true, true);
+
+    await goForward("about:config");
+    assertBackForwardState(true, false);
+
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  Services.prefs.clearUserPref("browser.navigation.requireUserInteraction");
+});
diff --git a/docshell/test/browser/browser_backforward_userinteraction_systemprincipal.js b/docshell/test/browser/browser_backforward_userinteraction_systemprincipal.js
new file mode 100644
index 0000000000..289ed1d133
--- /dev/null
+++ b/docshell/test/browser/browser_backforward_userinteraction_systemprincipal.js
@@ -0,0 +1,112 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "https://example.com"
+  ) + "dummy_page.html";
+
+async function runTest(privilegedLoad) {
+  let prefVals;
+  // Test with both pref on and off, unless parent-controlled pref is enabled.
+  // This distinction can be removed once SHIP is enabled by default.
+  if (
+    Services.prefs.getBoolPref("browser.tabs.documentchannel.parent-controlled")
+  ) {
+    prefVals = [false];
+  } else {
+    prefVals = [true, false];
+  }
+
+  for (let requireUserInteraction of prefVals) {
+    Services.prefs.setBoolPref(
+      "browser.navigation.requireUserInteraction",
+      requireUserInteraction
+    );
+
+    let tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      TEST_PAGE + "?entry=0"
+    );
+
+    assertBackForwardState(false, false);
+
+    await followLink(TEST_PAGE + "?entry=1");
+
+    assertBackForwardState(true, false);
+
+    await followLink(TEST_PAGE + "?entry=2");
+
+    assertBackForwardState(true, false);
+
+    await followLink(TEST_PAGE + "?entry=3");
+
+    assertBackForwardState(true, false);
+
+    // Entry 4 will be added through a user action in browser chrome,
+    // giving user interaction to entry 3. Entry 4 should not gain automatic
+    // user interaction.
+    await privilegedLoad(TEST_PAGE + "?entry=4");
+
+    assertBackForwardState(true, false);
+
+    await followLink(TEST_PAGE + "?entry=5");
+
+    assertBackForwardState(true, false);
+
+    if (!requireUserInteraction) {
+      await goBack(TEST_PAGE + "?entry=4");
+    }
+    await goBack(TEST_PAGE + "?entry=3");
+
+    if (!requireUserInteraction) {
+      await goBack(TEST_PAGE + "?entry=2");
+      await goBack(TEST_PAGE + "?entry=1");
+    }
+
+    assertBackForwardState(true, true);
+
+    await goBack(TEST_PAGE + "?entry=0");
+
+    assertBackForwardState(false, true);
+
+    if (!requireUserInteraction) {
+      await goForward(TEST_PAGE + "?entry=1");
+      await goForward(TEST_PAGE + "?entry=2");
+    }
+
+    await goForward(TEST_PAGE + "?entry=3");
+
+    assertBackForwardState(true, true);
+
+    if (!requireUserInteraction) {
+      await goForward(TEST_PAGE + "?entry=4");
+    }
+
+    await goForward(TEST_PAGE + "?entry=5");
+
+    assertBackForwardState(true, false);
+
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  Services.prefs.clearUserPref("browser.navigation.requireUserInteraction");
+}
+
+// Test that we add a user interaction flag to the previous site when loading
+// a new site from user interaction with privileged UI, e.g. through the
+// URL bar.
+add_task(async function test_urlBar() {
+  await runTest(async function (url) {
+    info(`Loading ${url} via the URL bar.`);
+    let browser = gBrowser.selectedBrowser;
+    let loaded = BrowserTestUtils.browserLoaded(browser, false, url);
+    gURLBar.focus();
+    gURLBar.value = url;
+    gURLBar.goButton.click();
+    await loaded;
+  });
+});
diff --git a/docshell/test/browser/browser_badCertDomainFixup.js b/docshell/test/browser/browser_badCertDomainFixup.js
new file mode 100644
index 0000000000..4bf6ddcef3
--- /dev/null
+++ b/docshell/test/browser/browser_badCertDomainFixup.js
@@ -0,0 +1,92 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// This test checks if we are correctly fixing https URLs by prefixing
+// with www. when we encounter a SSL_ERROR_BAD_CERT_DOMAIN error.
+// For example, https://example.com -> https://www.example.com.
+
+const PREF_BAD_CERT_DOMAIN_FIX_ENABLED =
+  "security.bad_cert_domain_error.url_fix_enabled";
+const PREF_ALLOW_HIJACKING_LOCALHOST =
+  "network.proxy.allow_hijacking_localhost";
+
+const BAD_CERT_DOMAIN_ERROR_URL = "https://badcertdomain.example.com:443";
+const FIXED_URL = "https://www.badcertdomain.example.com/";
+
+const BAD_CERT_DOMAIN_ERROR_URL2 =
+  "https://mismatch.badcertdomain.example.com:443";
+const IPV4_ADDRESS = "https://127.0.0.3:433";
+const BAD_CERT_DOMAIN_ERROR_PORT = "https://badcertdomain.example.com:82";
+
+async function verifyErrorPage(errorPageURL) {
+  let certErrorLoaded = BrowserTestUtils.waitForErrorPage(
+    gBrowser.selectedBrowser
+  );
+  BrowserTestUtils.startLoadingURIString(gBrowser, errorPageURL);
+  await certErrorLoaded;
+
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async function () {
+    let ec;
+    await ContentTaskUtils.waitForCondition(() => {
+      ec = content.document.getElementById("errorCode");
+      return ec.textContent;
+    }, "Error code has been set inside the advanced button panel");
+    is(
+      ec.textContent,
+      "SSL_ERROR_BAD_CERT_DOMAIN",
+      "Correct error code is shown"
+    );
+  });
+}
+
+// Test that "www." is prefixed to a https url when we encounter a bad cert domain
+// error if the "www." form is included in the certificate's subjectAltNames.
+add_task(async function prefixBadCertDomain() {
+  // Turn off the pref and ensure that we show the error page as expected.
+  Services.prefs.setBoolPref(PREF_BAD_CERT_DOMAIN_FIX_ENABLED, false);
+
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser);
+  await verifyErrorPage(BAD_CERT_DOMAIN_ERROR_URL);
+  info("Cert error is shown as expected when the fixup pref is disabled");
+
+  // Turn on the pref and test that we fix the HTTPS URL.
+  Services.prefs.setBoolPref(PREF_BAD_CERT_DOMAIN_FIX_ENABLED, true);
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser);
+  let loadSuccessful = BrowserTestUtils.browserLoaded(
+    gBrowser.selectedBrowser,
+    false,
+    FIXED_URL
+  );
+  BrowserTestUtils.startLoadingURIString(gBrowser, BAD_CERT_DOMAIN_ERROR_URL);
+  await loadSuccessful;
+
+  info("The URL was fixed as expected");
+
+  BrowserTestUtils.removeTab(gBrowser.selectedTab);
+  BrowserTestUtils.removeTab(gBrowser.selectedTab);
+});
+
+// Test that we don't prefix "www." to a https url when we encounter a bad cert domain
+// error under certain conditions.
+add_task(async function ignoreBadCertDomain() {
+  Services.prefs.setBoolPref(PREF_BAD_CERT_DOMAIN_FIX_ENABLED, true);
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser);
+
+  // Test for when "www." form is not present in the certificate.
+  await verifyErrorPage(BAD_CERT_DOMAIN_ERROR_URL2);
+  info("Certificate error was shown as expected");
+
+  // Test that urls with IP addresses are not fixed.
+  Services.prefs.setBoolPref(PREF_ALLOW_HIJACKING_LOCALHOST, true);
+  await verifyErrorPage(IPV4_ADDRESS);
+  Services.prefs.clearUserPref(PREF_ALLOW_HIJACKING_LOCALHOST);
+  info("Certificate error was shown as expected for an IP address");
+
+  // Test that urls with ports are not fixed.
+  await verifyErrorPage(BAD_CERT_DOMAIN_ERROR_PORT);
+  info("Certificate error was shown as expected for a host with port");
+
+  BrowserTestUtils.removeTab(gBrowser.selectedTab);
+});
diff --git a/docshell/test/browser/browser_bfcache_copycommand.js b/docshell/test/browser/browser_bfcache_copycommand.js
new file mode 100644
index 0000000000..cd0015ac03
--- /dev/null
+++ b/docshell/test/browser/browser_bfcache_copycommand.js
@@ -0,0 +1,98 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+function dummyPageURL(domain, query = "") {
+  return (
+    getRootDirectory(gTestPath).replace(
+      "chrome://mochitests/content",
+      `https://${domain}`
+    ) +
+    "dummy_page.html" +
+    query
+  );
+}
+
+async function openContextMenu(browser) {
+  let contextMenu = document.getElementById("contentAreaContextMenu");
+  let awaitPopupShown = BrowserTestUtils.waitForEvent(
+    contextMenu,
+    "popupshown"
+  );
+  await BrowserTestUtils.synthesizeMouse(
+    "body",
+    1,
+    1,
+    {
+      type: "contextmenu",
+      button: 2,
+    },
+    browser
+  );
+  await awaitPopupShown;
+}
+
+async function closeContextMenu() {
+  let contextMenu = document.getElementById("contentAreaContextMenu");
+  let awaitPopupHidden = BrowserTestUtils.waitForEvent(
+    contextMenu,
+    "popuphidden"
+  );
+  contextMenu.hidePopup();
+  await awaitPopupHidden;
+}
+
+async function testWithDomain(domain) {
+  // Passing a query to make sure the next load is never a same-document
+  // navigation.
+  let dummy = dummyPageURL("example.org", "?start");
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, dummy);
+  let browser = tab.linkedBrowser;
+
+  let sel = await SpecialPowers.spawn(browser, [], function () {
+    let sel = content.getSelection();
+    sel.removeAllRanges();
+    sel.selectAllChildren(content.document.body);
+    return sel.toString();
+  });
+
+  await openContextMenu(browser);
+
+  let copyItem = document.getElementById("context-copy");
+  ok(!copyItem.disabled, "Copy item should be enabled if text is selected.");
+
+  await closeContextMenu();
+
+  let loaded = BrowserTestUtils.browserLoaded(browser, false, null, true);
+  BrowserTestUtils.startLoadingURIString(browser, dummyPageURL(domain));
+  await loaded;
+  loaded = BrowserTestUtils.waitForLocationChange(gBrowser, dummy);
+  browser.goBack();
+  await loaded;
+
+  let sel2 = await SpecialPowers.spawn(browser, [], function () {
+    return content.getSelection().toString();
+  });
+  is(sel, sel2, "Selection should remain when coming out of BFCache.");
+
+  await openContextMenu(browser);
+
+  ok(!copyItem.disabled, "Copy item should be enabled if text is selected.");
+
+  await closeContextMenu();
+
+  await BrowserTestUtils.removeTab(tab);
+}
+
+add_task(async function testValidSameOrigin() {
+  await testWithDomain("example.org");
+});
+
+add_task(async function testValidCrossOrigin() {
+  await testWithDomain("example.com");
+});
+
+add_task(async function testInvalid() {
+  await testWithDomain("this.is.invalid");
+});
diff --git a/docshell/test/browser/browser_browsingContext-01.js b/docshell/test/browser/browser_browsingContext-01.js
new file mode 100644
index 0000000000..95831d2567
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-01.js
@@ -0,0 +1,180 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const URL = "about:blank";
+
+async function getBrowsingContextId(browser, id) {
+  return SpecialPowers.spawn(browser, [id], async function (id) {
+    let contextId = content.window.docShell.browsingContext.id;
+
+    let frames = [content.window];
+    while (frames.length) {
+      let frame = frames.pop();
+      let target = frame.document.getElementById(id);
+      if (target) {
+        contextId = target.docShell.browsingContext.id;
+        break;
+      }
+
+      frames = frames.concat(Array.from(frame.frames));
+    }
+
+    return contextId;
+  });
+}
+
+async function addFrame(browser, id, parentId) {
+  return SpecialPowers.spawn(
+    browser,
+    [{ parentId, id }],
+    async function ({ parentId, id }) {
+      let parent = null;
+      if (parentId) {
+        let frames = [content.window];
+        while (frames.length) {
+          let frame = frames.pop();
+          let target = frame.document.getElementById(parentId);
+          if (target) {
+            parent = target.contentWindow.document.body;
+            break;
+          }
+          frames = frames.concat(Array.from(frame.frames));
+        }
+      } else {
+        parent = content.document.body;
+      }
+
+      let frame = await new Promise(resolve => {
+        let frame = content.document.createElement("iframe");
+        frame.id = id || "";
+        frame.url = "about:blank";
+        frame.onload = () => resolve(frame);
+        parent.appendChild(frame);
+      });
+
+      return frame.contentWindow.docShell.browsingContext.id;
+    }
+  );
+}
+
+async function removeFrame(browser, id) {
+  return SpecialPowers.spawn(browser, [id], async function (id) {
+    let frames = [content.window];
+    while (frames.length) {
+      let frame = frames.pop();
+      let target = frame.document.getElementById(id);
+      if (target) {
+        target.remove();
+        break;
+      }
+
+      frames = frames.concat(Array.from(frame.frames));
+    }
+  });
+}
+
+function getBrowsingContextById(id) {
+  return BrowsingContext.get(id);
+}
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: URL },
+    async function (browser) {
+      let topId = await getBrowsingContextId(browser, "");
+      let topContext = getBrowsingContextById(topId);
+      isnot(topContext, null);
+      is(topContext.parent, null);
+      is(
+        topId,
+        browser.browsingContext.id,
+        "<browser> has the correct browsingContext"
+      );
+      is(
+        browser.browserId,
+        topContext.browserId,
+        "browsing context should have a correct <browser> id"
+      );
+
+      let id0 = await addFrame(browser, "frame0");
+      let browsingContext0 = getBrowsingContextById(id0);
+      isnot(browsingContext0, null);
+      is(browsingContext0.parent, topContext);
+
+      await removeFrame(browser, "frame0");
+
+      is(topContext.children.indexOf(browsingContext0), -1);
+
+      // TODO(farre): Handle browsingContext removal [see Bug 1486719].
+      todo_isnot(browsingContext0.parent, topContext);
+    }
+  );
+});
+
+add_task(async function () {
+  // If Fission is disabled, the pref is no-op.
+  await SpecialPowers.pushPrefEnv({ set: [["fission.bfcacheInParent", true]] });
+
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url:
+        getRootDirectory(gTestPath).replace(
+          "chrome://mochitests/content",
+          // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+          "http://example.com"
+        ) + "dummy_page.html",
+    },
+    async function (browser) {
+      let path = getRootDirectory(gTestPath).replace(
+        "chrome://mochitests/content",
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        "http://example.com"
+      );
+      await SpecialPowers.spawn(browser, [path], async function (path) {
+        var bc = new content.BroadcastChannel("browser_browsingContext");
+        function waitForMessage(command) {
+          let p = new Promise(resolve => {
+            bc.addEventListener("message", e => resolve(e), { once: true });
+          });
+          command();
+          return p;
+        }
+
+        // Open a new window and wait for the message.
+        let e1 = await waitForMessage(_ =>
+          content.window.open(path + "onpageshow_message.html", "", "noopener")
+        );
+
+        is(e1.data, "pageshow", "Got page show");
+
+        let e2 = await waitForMessage(_ => bc.postMessage("createiframe"));
+        is(e2.data.framesLength, 1, "Here we should have an iframe");
+
+        let e3 = await waitForMessage(_ => bc.postMessage("nextpage"));
+
+        is(e3.data.event, "load");
+        is(e3.data.framesLength, 0, "Here there shouldn't be an iframe");
+
+        // Return to the previous document. N.B. we expect to trigger
+        // BFCache here, hence we wait for pageshow.
+        let e4 = await waitForMessage(_ => bc.postMessage("back"));
+
+        is(e4.data, "pageshow");
+
+        let e5 = await waitForMessage(_ => bc.postMessage("queryframes"));
+        is(e5.data.framesLength, 1, "And again there should be an iframe");
+
+        is(e5.outerWindowId, e2.outerWindowId, "BF cache cached outer window");
+        is(e5.browsingContextId, e2.browsingContextId, "BF cache cached BC");
+
+        let e6 = await waitForMessage(_ => bc.postMessage("close"));
+        is(e6.data, "closed");
+
+        bc.close();
+      });
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_browsingContext-02.js b/docshell/test/browser/browser_browsingContext-02.js
new file mode 100644
index 0000000000..8439b869b0
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-02.js
@@ -0,0 +1,235 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function (browser) {
+      const BASE1 = getRootDirectory(gTestPath).replace(
+        "chrome://mochitests/content",
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        "http://example.com"
+      );
+      const BASE2 = getRootDirectory(gTestPath).replace(
+        "chrome://mochitests/content",
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        "http://test1.example.com"
+      );
+      const URL = BASE1 + "onload_message.html";
+      let sixth = BrowserTestUtils.waitForNewTab(
+        gBrowser,
+        URL + "#sixth",
+        true,
+        true
+      );
+      let seventh = BrowserTestUtils.waitForNewTab(
+        gBrowser,
+        URL + "#seventh",
+        true,
+        true
+      );
+      let browserIds = await SpecialPowers.spawn(
+        browser,
+        [{ base1: BASE1, base2: BASE2 }],
+        async function ({ base1, base2 }) {
+          let top = content;
+          top.name = "top";
+          top.location.href += "#top";
+
+          let contexts = {
+            top: top.location.href,
+            first: base1 + "dummy_page.html#first",
+            third: base2 + "dummy_page.html#third",
+            second: base1 + "dummy_page.html#second",
+            fourth: base2 + "dummy_page.html#fourth",
+            fifth: base1 + "dummy_page.html#fifth",
+            sixth: base1 + "onload_message.html#sixth",
+            seventh: base1 + "onload_message.html#seventh",
+          };
+
+          function addFrame(target, name) {
+            return content.SpecialPowers.spawn(
+              target,
+              [name, contexts[name]],
+              async (name, context) => {
+                let doc = this.content.document;
+
+                let frame = doc.createElement("iframe");
+                doc.body.appendChild(frame);
+                frame.name = name;
+                frame.src = context;
+                await new Promise(resolve => {
+                  frame.addEventListener("load", resolve, { once: true });
+                });
+                return frame.browsingContext;
+              }
+            );
+          }
+
+          function addWindow(target, name, { options, resolve }) {
+            return content.SpecialPowers.spawn(
+              target,
+              [name, contexts[name], options, resolve],
+              (name, context, options, resolve) => {
+                let win = this.content.open(context, name, options);
+                let bc = win && win.docShell.browsingContext;
+
+                if (resolve) {
+                  return new Promise(resolve =>
+                    this.content.addEventListener("message", () => resolve(bc))
+                  );
+                }
+                return Promise.resolve({ name });
+              }
+            );
+          }
+
+          // We're going to create a tree that looks like the
+          // following.
+          //
+          //           top          sixth    seventh
+          //          /   \
+          //         /     \        /
+          //      first  second
+          //      /   \           /
+          //     /     \
+          //  third  fourth - - -
+          //          /
+          //         /
+          //      fifth
+          //
+          // The idea is to have one top level non-auxiliary browsing
+          // context, five nested, one top level auxiliary with an
+          // opener, and one top level without an opener. Given that
+          // set of related and one unrelated browsing contexts we
+          // wish to confirm that targeting is able to find
+          // appropriate browsing contexts.
+
+          // WindowGlobalChild.findBrowsingContextWithName requires access
+          // checks, which can only be performed in the process of the accessor
+          // WindowGlobalChild.
+          function findWithName(bc, name) {
+            return content.SpecialPowers.spawn(bc, [name], name => {
+              return content.windowGlobalChild.findBrowsingContextWithName(
+                name
+              );
+            });
+          }
+
+          async function reachable(start, target) {
+            info(start.name, target.name);
+            is(
+              await findWithName(start, target.name),
+              target,
+              [start.name, "can reach", target.name].join(" ")
+            );
+          }
+
+          async function unreachable(start, target) {
+            is(
+              await findWithName(start, target.name),
+              null,
+              [start.name, "can't reach", target.name].join(" ")
+            );
+          }
+
+          let first = await addFrame(top, "first");
+          info("first");
+          let second = await addFrame(top, "second");
+          info("second");
+          let third = await addFrame(first, "third");
+          info("third");
+          let fourth = await addFrame(first, "fourth");
+          info("fourth");
+          let fifth = await addFrame(fourth, "fifth");
+          info("fifth");
+          let sixth = await addWindow(fourth, "sixth", { resolve: true });
+          info("sixth");
+          let seventh = await addWindow(fourth, "seventh", {
+            options: ["noopener"],
+          });
+          info("seventh");
+
+          let origin1 = [first, second, fifth, sixth];
+          let origin2 = [third, fourth];
+
+          let topBC = BrowsingContext.getFromWindow(top);
+          let frames = new Map([
+            [topBC, [topBC, first, second, third, fourth, fifth, sixth]],
+            [first, [topBC, ...origin1, third, fourth]],
+            [second, [topBC, ...origin1, third, fourth]],
+            [third, [topBC, ...origin2, fifth, sixth]],
+            [fourth, [topBC, ...origin2, fifth, sixth]],
+            [fifth, [topBC, ...origin1, third, fourth]],
+            [sixth, [...origin1, third, fourth]],
+          ]);
+
+          for (let [start, accessible] of frames) {
+            for (let frame of frames.keys()) {
+              if (accessible.includes(frame)) {
+                await reachable(start, frame);
+              } else {
+                await unreachable(start, frame);
+              }
+            }
+            await unreachable(start, seventh);
+          }
+
+          let topBrowserId = topBC.browserId;
+          ok(topBrowserId > 0, "Should have a browser ID.");
+          for (let [name, bc] of Object.entries({
+            first,
+            second,
+            third,
+            fourth,
+            fifth,
+          })) {
+            is(
+              bc.browserId,
+              topBrowserId,
+              `${name} frame should have the same browserId as top.`
+            );
+          }
+
+          ok(sixth.browserId > 0, "sixth should have a browserId.");
+          isnot(
+            sixth.browserId,
+            topBrowserId,
+            "sixth frame should have a different browserId to top."
+          );
+
+          return [topBrowserId, sixth.browserId];
+        }
+      );
+
+      [sixth, seventh] = await Promise.all([sixth, seventh]);
+
+      is(
+        browser.browserId,
+        browserIds[0],
+        "browser should have the right browserId."
+      );
+      is(
+        browser.browsingContext.browserId,
+        browserIds[0],
+        "browser's BrowsingContext should have the right browserId."
+      );
+      is(
+        sixth.linkedBrowser.browserId,
+        browserIds[1],
+        "sixth should have the right browserId."
+      );
+      is(
+        sixth.linkedBrowser.browsingContext.browserId,
+        browserIds[1],
+        "sixth's BrowsingContext should have the right browserId."
+      );
+
+      for (let tab of [sixth, seventh]) {
+        BrowserTestUtils.removeTab(tab);
+      }
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_browsingContext-embedder.js b/docshell/test/browser/browser_browsingContext-embedder.js
new file mode 100644
index 0000000000..9473a46eb4
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-embedder.js
@@ -0,0 +1,156 @@
+"use strict";
+
+function observeOnce(topic) {
+  return new Promise(resolve => {
+    Services.obs.addObserver(function observer(aSubject, aTopic) {
+      if (topic == aTopic) {
+        Services.obs.removeObserver(observer, topic);
+        setTimeout(() => resolve(aSubject), 0);
+      }
+    }, topic);
+  });
+}
+
+add_task(async function runTest() {
+  let fissionWindow = await BrowserTestUtils.openNewBrowserWindow({
+    fission: true,
+    remote: true,
+  });
+
+  info(`chrome, parent`);
+  let chromeBC = fissionWindow.docShell.browsingContext;
+  ok(chromeBC.currentWindowGlobal, "Should have a current WindowGlobal");
+  is(chromeBC.embedderWindowGlobal, null, "chrome has no embedder global");
+  is(chromeBC.embedderElement, null, "chrome has no embedder element");
+  is(chromeBC.parent, null, "chrome has no parent");
+
+  // Open a new tab, and check that basic frames work out.
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: fissionWindow.gBrowser,
+  });
+
+  info(`root, parent`);
+  let rootBC = tab.linkedBrowser.browsingContext;
+  ok(rootBC.currentWindowGlobal, "[parent] root has a window global");
+  is(
+    rootBC.embedderWindowGlobal,
+    chromeBC.currentWindowGlobal,
+    "[parent] root has chrome as embedder global"
+  );
+  is(
+    rootBC.embedderElement,
+    tab.linkedBrowser,
+    "[parent] root has browser as embedder element"
+  );
+  is(rootBC.parent, null, "[parent] root has no parent");
+
+  // Test with an in-process frame
+  let frameId = await SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    info(`root, child`);
+    let rootBC = content.docShell.browsingContext;
+    is(rootBC.embedderElement, null, "[child] root has no embedder");
+    is(rootBC.parent, null, "[child] root has no parent");
+
+    info(`frame, child`);
+    let iframe = content.document.createElement("iframe");
+    content.document.body.appendChild(iframe);
+
+    let frameBC = iframe.contentWindow.docShell.browsingContext;
+    is(frameBC.embedderElement, iframe, "[child] frame embedded within iframe");
+    is(frameBC.parent, rootBC, "[child] frame has root as parent");
+
+    return frameBC.id;
+  });
+
+  info(`frame, parent`);
+  let frameBC = BrowsingContext.get(frameId);
+  ok(frameBC.currentWindowGlobal, "[parent] frame has a window global");
+  is(
+    frameBC.embedderWindowGlobal,
+    rootBC.currentWindowGlobal,
+    "[parent] frame has root as embedder global"
+  );
+  is(frameBC.embedderElement, null, "[parent] frame has no embedder element");
+  is(frameBC.parent, rootBC, "[parent] frame has root as parent");
+
+  // Test with an out-of-process iframe.
+
+  let oopID = await SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    info(`creating oop iframe`);
+    let oop = content.document.createElement("iframe");
+    oop.setAttribute("src", "https://example.com");
+    content.document.body.appendChild(oop);
+
+    await new Promise(resolve => {
+      oop.addEventListener("load", resolve, { once: true });
+    });
+
+    info(`oop frame, child`);
+    let oopBC = oop.frameLoader.browsingContext;
+    is(oopBC.embedderElement, oop, "[child] oop frame embedded within iframe");
+    is(
+      oopBC.parent,
+      content.docShell.browsingContext,
+      "[child] frame has root as parent"
+    );
+
+    return oopBC.id;
+  });
+
+  info(`oop frame, parent`);
+  let oopBC = BrowsingContext.get(oopID);
+  is(
+    oopBC.embedderWindowGlobal,
+    rootBC.currentWindowGlobal,
+    "[parent] oop frame has root as embedder global"
+  );
+  is(oopBC.embedderElement, null, "[parent] oop frame has no embedder element");
+  is(oopBC.parent, rootBC, "[parent] oop frame has root as parent");
+
+  info(`waiting for oop window global`);
+  ok(oopBC.currentWindowGlobal, "[parent] oop frame has a window global");
+
+  // Open a new window, and adopt |tab| into it.
+
+  let newWindow = await BrowserTestUtils.openNewBrowserWindow({
+    fission: true,
+    remote: true,
+  });
+
+  info(`new chrome, parent`);
+  let newChromeBC = newWindow.docShell.browsingContext;
+  ok(newChromeBC.currentWindowGlobal, "Should have a current WindowGlobal");
+  is(
+    newChromeBC.embedderWindowGlobal,
+    null,
+    "new chrome has no embedder global"
+  );
+  is(newChromeBC.embedderElement, null, "new chrome has no embedder element");
+  is(newChromeBC.parent, null, "new chrome has no parent");
+
+  isnot(newChromeBC, chromeBC, "different chrome browsing context");
+
+  info(`adopting tab`);
+  let newTab = newWindow.gBrowser.adoptTab(tab);
+
+  is(
+    newTab.linkedBrowser.browsingContext,
+    rootBC,
+    "[parent] root browsing context survived"
+  );
+  is(
+    rootBC.embedderWindowGlobal,
+    newChromeBC.currentWindowGlobal,
+    "[parent] embedder window global updated"
+  );
+  is(
+    rootBC.embedderElement,
+    newTab.linkedBrowser,
+    "[parent] embedder element updated"
+  );
+  is(rootBC.parent, null, "[parent] root has no parent");
+
+  info(`closing window`);
+  await BrowserTestUtils.closeWindow(newWindow);
+  await BrowserTestUtils.closeWindow(fissionWindow);
+});
diff --git a/docshell/test/browser/browser_browsingContext-getAllBrowsingContextsInSubtree.js b/docshell/test/browser/browser_browsingContext-getAllBrowsingContextsInSubtree.js
new file mode 100644
index 0000000000..076383ad87
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-getAllBrowsingContextsInSubtree.js
@@ -0,0 +1,53 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+async function addFrame(url) {
+  let iframe = content.document.createElement("iframe");
+  await new Promise(resolve => {
+    iframe.addEventListener("load", resolve, { once: true });
+    iframe.src = url;
+    content.document.body.appendChild(iframe);
+  });
+  return iframe.browsingContext;
+}
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async browser => {
+      // Add 15 example.com frames to the toplevel document.
+      let frames = await Promise.all(
+        Array.from({ length: 15 }).map(_ =>
+          // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+          SpecialPowers.spawn(browser, ["http://example.com/"], addFrame)
+        )
+      );
+
+      // Add an example.org subframe to each example.com frame.
+      let subframes = await Promise.all(
+        Array.from({ length: 15 }).map((_, i) =>
+          // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+          SpecialPowers.spawn(frames[i], ["http://example.org/"], addFrame)
+        )
+      );
+
+      Assert.deepEqual(
+        subframes[0].getAllBrowsingContextsInSubtree(),
+        [subframes[0]],
+        "Childless context only has self in subtree"
+      );
+      Assert.deepEqual(
+        frames[0].getAllBrowsingContextsInSubtree(),
+        [frames[0], subframes[0]],
+        "Single-child context has 2 contexts in subtree"
+      );
+      Assert.deepEqual(
+        browser.browsingContext.getAllBrowsingContextsInSubtree(),
+        [browser.browsingContext, ...frames, ...subframes],
+        "Toplevel context has all subtree contexts"
+      );
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_browsingContext-getWindowByName.js b/docshell/test/browser/browser_browsingContext-getWindowByName.js
new file mode 100644
index 0000000000..e57691b270
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-getWindowByName.js
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+function addWindow(name) {
+  var blank = Cc["@mozilla.org/supports-string;1"].createInstance(
+    Ci.nsISupportsString
+  );
+  blank.data = "about:blank";
+  let promise = BrowserTestUtils.waitForNewWindow({
+    anyWindow: true,
+    url: "about:blank",
+  });
+  Services.ww.openWindow(
+    null,
+    AppConstants.BROWSER_CHROME_URL,
+    name,
+    "chrome,dialog=no",
+    blank
+  );
+  return promise;
+}
+
+add_task(async function () {
+  let windows = [await addWindow("first"), await addWindow("second")];
+
+  for (let w of windows) {
+    isnot(w, null);
+    is(Services.ww.getWindowByName(w.name, null), w, `Found ${w.name}`);
+  }
+
+  await Promise.all(windows.map(BrowserTestUtils.closeWindow));
+});
diff --git a/docshell/test/browser/browser_browsingContext-webProgress.js b/docshell/test/browser/browser_browsingContext-webProgress.js
new file mode 100644
index 0000000000..225242be60
--- /dev/null
+++ b/docshell/test/browser/browser_browsingContext-webProgress.js
@@ -0,0 +1,226 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function () {
+  const tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  const browser = tab.linkedBrowser;
+  const aboutBlankBrowsingContext = browser.browsingContext;
+  const { webProgress } = aboutBlankBrowsingContext;
+  ok(
+    webProgress,
+    "Got a WebProgress interface on BrowsingContext in the parent process"
+  );
+  is(
+    webProgress.browsingContext,
+    browser.browsingContext,
+    "WebProgress.browsingContext refers to the right BrowsingContext"
+  );
+
+  const onLocationChanged = waitForNextLocationChange(webProgress);
+  const newLocation = "data:text/html;charset=utf-8,first-page";
+  let loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.startLoadingURIString(browser, newLocation);
+  await loaded;
+
+  const firstPageBrowsingContext = browser.browsingContext;
+  const isBfcacheInParentEnabled =
+    SpecialPowers.Services.appinfo.sessionHistoryInParent &&
+    SpecialPowers.Services.prefs.getBoolPref("fission.bfcacheInParent");
+  if (isBfcacheInParentEnabled) {
+    isnot(
+      aboutBlankBrowsingContext,
+      firstPageBrowsingContext,
+      "With bfcache in parent, navigations spawn a new BrowsingContext"
+    );
+  } else {
+    is(
+      aboutBlankBrowsingContext,
+      firstPageBrowsingContext,
+      "Without bfcache in parent, navigations reuse the same BrowsingContext"
+    );
+  }
+
+  info("Wait for onLocationChange to be fired");
+  {
+    const { browsingContext, location, request, flags } =
+      await onLocationChanged;
+    is(
+      browsingContext,
+      firstPageBrowsingContext,
+      "Location change fires on the new BrowsingContext"
+    );
+    ok(location instanceof Ci.nsIURI);
+    is(location.spec, newLocation);
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, newLocation);
+    is(flags, 0);
+  }
+
+  const onIframeLocationChanged = waitForNextLocationChange(webProgress);
+  const iframeLocation = "data:text/html;charset=utf-8,iframe";
+  const iframeBC = await SpecialPowers.spawn(
+    browser,
+    [iframeLocation],
+    async url => {
+      const iframe = content.document.createElement("iframe");
+      await new Promise(resolve => {
+        iframe.addEventListener("load", resolve, { once: true });
+        iframe.src = url;
+        content.document.body.appendChild(iframe);
+      });
+
+      return iframe.browsingContext;
+    }
+  );
+  ok(
+    iframeBC.webProgress,
+    "The iframe BrowsingContext also exposes a WebProgress"
+  );
+  {
+    const { browsingContext, location, request, flags } =
+      await onIframeLocationChanged;
+    is(
+      browsingContext,
+      iframeBC,
+      "Iframe location change fires on the iframe BrowsingContext"
+    );
+    ok(location instanceof Ci.nsIURI);
+    is(location.spec, iframeLocation);
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, iframeLocation);
+    is(flags, 0);
+  }
+
+  const onSecondLocationChanged = waitForNextLocationChange(webProgress);
+  const onSecondPageDocumentStart = waitForNextDocumentStart(webProgress);
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  const secondLocation = "http://example.com/document-builder.sjs?html=com";
+  loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.startLoadingURIString(browser, secondLocation);
+  await loaded;
+
+  const secondPageBrowsingContext = browser.browsingContext;
+  if (isBfcacheInParentEnabled) {
+    isnot(
+      firstPageBrowsingContext,
+      secondPageBrowsingContext,
+      "With bfcache in parent, navigations spawn a new BrowsingContext"
+    );
+  } else {
+    is(
+      firstPageBrowsingContext,
+      secondPageBrowsingContext,
+      "Without bfcache in parent, navigations reuse the same BrowsingContext"
+    );
+  }
+  {
+    const { browsingContext, location, request, flags } =
+      await onSecondLocationChanged;
+    is(
+      browsingContext,
+      secondPageBrowsingContext,
+      "Second location change fires on the new BrowsingContext"
+    );
+    ok(location instanceof Ci.nsIURI);
+    is(location.spec, secondLocation);
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, secondLocation);
+    is(flags, 0);
+  }
+  {
+    const { browsingContext, request } = await onSecondPageDocumentStart;
+    is(
+      browsingContext,
+      firstPageBrowsingContext,
+      "STATE_START, when navigating to another process, fires on the BrowsingContext we navigate *from*"
+    );
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, secondLocation);
+  }
+
+  const onBackLocationChanged = waitForNextLocationChange(webProgress, true);
+  const onBackDocumentStart = waitForNextDocumentStart(webProgress);
+  browser.goBack();
+
+  {
+    const { browsingContext, location, request, flags } =
+      await onBackLocationChanged;
+    is(
+      browsingContext,
+      firstPageBrowsingContext,
+      "location change, when navigating back, fires on the BrowsingContext we navigate *to*"
+    );
+    ok(location instanceof Ci.nsIURI);
+    is(location.spec, newLocation);
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, newLocation);
+    is(flags, 0);
+  }
+  {
+    const { browsingContext, request } = await onBackDocumentStart;
+    is(
+      browsingContext,
+      secondPageBrowsingContext,
+      "STATE_START, when navigating back, fires on the BrowsingContext we navigate *from*"
+    );
+    ok(request instanceof Ci.nsIChannel);
+    is(request.URI.spec, newLocation);
+  }
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+function waitForNextLocationChange(webProgress, onlyTopLevel = false) {
+  return new Promise(resolve => {
+    const wpl = {
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIWebProgressListener",
+        "nsISupportsWeakReference",
+      ]),
+      onLocationChange(progress, request, location, flags) {
+        if (onlyTopLevel && progress.browsingContext.parent) {
+          // Ignore non-toplevel.
+          return;
+        }
+        webProgress.removeProgressListener(wpl, Ci.nsIWebProgress.NOTIFY_ALL);
+        resolve({
+          browsingContext: progress.browsingContext,
+          location,
+          request,
+          flags,
+        });
+      },
+    };
+    // Add a strong reference to the progress listener.
+    resolve.wpl = wpl;
+    webProgress.addProgressListener(wpl, Ci.nsIWebProgress.NOTIFY_ALL);
+  });
+}
+
+function waitForNextDocumentStart(webProgress) {
+  return new Promise(resolve => {
+    const wpl = {
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIWebProgressListener",
+        "nsISupportsWeakReference",
+      ]),
+      onStateChange(progress, request, flags, status) {
+        if (
+          flags & Ci.nsIWebProgressListener.STATE_IS_DOCUMENT &&
+          flags & Ci.nsIWebProgressListener.STATE_START
+        ) {
+          webProgress.removeProgressListener(wpl, Ci.nsIWebProgress.NOTIFY_ALL);
+          resolve({ browsingContext: progress.browsingContext, request });
+        }
+      },
+    };
+    // Add a strong reference to the progress listener.
+    resolve.wpl = wpl;
+    webProgress.addProgressListener(wpl, Ci.nsIWebProgress.NOTIFY_ALL);
+  });
+}
diff --git a/docshell/test/browser/browser_browsing_context_attached.js b/docshell/test/browser/browser_browsing_context_attached.js
new file mode 100644
index 0000000000..60ef5e4aa6
--- /dev/null
+++ b/docshell/test/browser/browser_browsing_context_attached.js
@@ -0,0 +1,179 @@
+"use strict";
+
+const TEST_PATH =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.com"
+  ) + "dummy_page.html";
+
+const TOPIC = "browsing-context-attached";
+
+async function observeAttached(callback) {
+  let attached = new Map();
+
+  function observer(subject, topic, data) {
+    is(topic, TOPIC, "observing correct topic");
+    ok(BrowsingContext.isInstance(subject), "subject to be a BrowsingContext");
+    is(typeof data, "string", "data to be a String");
+    info(`*** bc id=${subject.id}, why=${data}`);
+    attached.set(subject.id, { browsingContext: subject, why: data });
+  }
+
+  Services.obs.addObserver(observer, TOPIC);
+  try {
+    await callback();
+    return attached;
+  } finally {
+    Services.obs.removeObserver(observer, TOPIC);
+  }
+}
+
+add_task(async function toplevelForNewWindow() {
+  let win;
+
+  let attached = await observeAttached(async () => {
+    win = await BrowserTestUtils.openNewBrowserWindow();
+  });
+
+  ok(
+    attached.has(win.browsingContext.id),
+    "got notification for window's chrome browsing context"
+  );
+  is(
+    attached.get(win.browsingContext.id).why,
+    "attach",
+    "expected reason for chrome browsing context"
+  );
+
+  ok(
+    attached.has(win.gBrowser.selectedBrowser.browsingContext.id),
+    "got notification for toplevel browsing context"
+  );
+  is(
+    attached.get(win.gBrowser.selectedBrowser.browsingContext.id).why,
+    "attach",
+    "expected reason for toplevel browsing context"
+  );
+
+  await BrowserTestUtils.closeWindow(win);
+});
+
+add_task(async function toplevelForNewTab() {
+  let tab;
+
+  let attached = await observeAttached(async () => {
+    tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+  });
+
+  ok(
+    !attached.has(window.browsingContext.id),
+    "no notification for the current window's chrome browsing context"
+  );
+  ok(
+    attached.has(tab.linkedBrowser.browsingContext.id),
+    "got notification for toplevel browsing context"
+  );
+  is(
+    attached.get(tab.linkedBrowser.browsingContext.id).why,
+    "attach",
+    "expected reason for toplevel browsing context"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function subframe() {
+  let browsingContext;
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+
+  let attached = await observeAttached(async () => {
+    browsingContext = await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+      let iframe = content.document.createElement("iframe");
+      content.document.body.appendChild(iframe);
+      iframe.contentWindow.location = "https://example.com/";
+      return iframe.browsingContext;
+    });
+  });
+
+  ok(
+    !attached.has(window.browsingContext.id),
+    "no notification for the current window's chrome browsing context"
+  );
+  ok(
+    !attached.has(tab.linkedBrowser.browsingContext.id),
+    "no notification for toplevel browsing context"
+  );
+  ok(
+    attached.has(browsingContext.id),
+    "got notification for frame's browsing context"
+  );
+  is(
+    attached.get(browsingContext.id).why,
+    "attach",
+    "expected reason for frame's browsing context"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function toplevelReplacedBy() {
+  let tab;
+
+  let attached = await observeAttached(async () => {
+    tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots");
+  });
+
+  const firstContext = tab.linkedBrowser.browsingContext;
+  ok(
+    attached.has(firstContext.id),
+    "got notification for initial toplevel browsing context"
+  );
+  is(
+    attached.get(firstContext.id).why,
+    "attach",
+    "expected reason for initial toplevel browsing context"
+  );
+
+  attached = await observeAttached(async () => {
+    await loadURI(TEST_PATH);
+  });
+  const secondContext = tab.linkedBrowser.browsingContext;
+  ok(
+    attached.has(secondContext.id),
+    "got notification for replaced toplevel browsing context"
+  );
+  isnot(secondContext, firstContext, "browsing context to be replaced");
+  is(
+    attached.get(secondContext.id).why,
+    "replace",
+    "expected reason for replaced toplevel browsing context"
+  );
+  is(
+    secondContext.browserId,
+    firstContext.browserId,
+    "browserId has been kept"
+  );
+
+  attached = await observeAttached(async () => {
+    await loadURI("about:robots");
+  });
+  const thirdContext = tab.linkedBrowser.browsingContext;
+  ok(
+    attached.has(thirdContext.id),
+    "got notification for replaced toplevel browsing context"
+  );
+  isnot(thirdContext, secondContext, "browsing context to be replaced");
+  is(
+    attached.get(thirdContext.id).why,
+    "replace",
+    "expected reason for replaced toplevel browsing context"
+  );
+  is(
+    thirdContext.browserId,
+    secondContext.browserId,
+    "browserId has been kept"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/docshell/test/browser/browser_browsing_context_discarded.js b/docshell/test/browser/browser_browsing_context_discarded.js
new file mode 100644
index 0000000000..a300737d4f
--- /dev/null
+++ b/docshell/test/browser/browser_browsing_context_discarded.js
@@ -0,0 +1,65 @@
+"use strict";
+
+const TOPIC = "browsing-context-discarded";
+
+async function observeDiscarded(browsingContexts, callback) {
+  let discarded = [];
+
+  let promise = BrowserUtils.promiseObserved(TOPIC, subject => {
+    ok(BrowsingContext.isInstance(subject), "subject to be a BrowsingContext");
+    discarded.push(subject);
+
+    return browsingContexts.every(item => discarded.includes(item));
+  });
+  await callback();
+  await promise;
+
+  return discarded;
+}
+
+add_task(async function toplevelForNewWindow() {
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  let browsingContext = win.gBrowser.selectedBrowser.browsingContext;
+
+  await observeDiscarded([win.browsingContext, browsingContext], async () => {
+    await BrowserTestUtils.closeWindow(win);
+  });
+});
+
+add_task(async function toplevelForNewTab() {
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+  let browsingContext = tab.linkedBrowser.browsingContext;
+
+  let discarded = await observeDiscarded([browsingContext], () => {
+    BrowserTestUtils.removeTab(tab);
+  });
+
+  ok(
+    !discarded.includes(window.browsingContext),
+    "no notification for the current window's chrome browsing context"
+  );
+});
+
+add_task(async function subframe() {
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+  let browsingContext = await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+    let iframe = content.document.createElement("iframe");
+    content.document.body.appendChild(iframe);
+    iframe.contentWindow.location = "https://example.com/";
+    return iframe.browsingContext;
+  });
+
+  let discarded = await observeDiscarded([browsingContext], async () => {
+    await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+      let iframe = content.document.querySelector("iframe");
+      iframe.remove();
+    });
+  });
+
+  ok(
+    !discarded.includes(tab.browsingContext),
+    "no notification for toplevel browsing context"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/docshell/test/browser/browser_bug1206879.js b/docshell/test/browser/browser_bug1206879.js
new file mode 100644
index 0000000000..38e17633b8
--- /dev/null
+++ b/docshell/test/browser/browser_bug1206879.js
@@ -0,0 +1,50 @@
+add_task(async function () {
+  let url =
+    getRootDirectory(gTestPath).replace(
+      "chrome://mochitests/content/",
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+      "http://example.com/"
+    ) + "file_bug1206879.html";
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url, true);
+
+  let numLocationChanges = await SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [],
+    async function () {
+      let webprogress = content.docShell.QueryInterface(Ci.nsIWebProgress);
+      let locationChangeCount = 0;
+      let listener = {
+        onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
+          info("onLocationChange: " + aLocation.spec);
+          locationChangeCount++;
+          this.resolve();
+        },
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIWebProgressListener",
+          "nsISupportsWeakReference",
+        ]),
+      };
+      let locationPromise = new Promise((resolve, reject) => {
+        listener.resolve = resolve;
+      });
+      webprogress.addProgressListener(
+        listener,
+        Ci.nsIWebProgress.NOTIFY_LOCATION
+      );
+
+      content.frames[0].history.pushState(null, null, "foo");
+
+      await locationPromise;
+      webprogress.removeProgressListener(listener);
+
+      return locationChangeCount;
+    }
+  );
+
+  gBrowser.removeTab(tab);
+  is(
+    numLocationChanges,
+    1,
+    "pushState with a different URI should cause a LocationChange event."
+  );
+});
diff --git a/docshell/test/browser/browser_bug1309900_crossProcessHistoryNavigation.js b/docshell/test/browser/browser_bug1309900_crossProcessHistoryNavigation.js
new file mode 100644
index 0000000000..6b577a4d12
--- /dev/null
+++ b/docshell/test/browser/browser_bug1309900_crossProcessHistoryNavigation.js
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+add_task(async function runTests() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.navigation.requireUserInteraction", false]],
+  });
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:about"
+  );
+
+  registerCleanupFunction(function () {
+    gBrowser.removeTab(tab);
+  });
+
+  let browser = tab.linkedBrowser;
+
+  let loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.startLoadingURIString(browser, "about:config");
+  let href = await loaded;
+  is(href, "about:config", "Check about:config loaded");
+
+  // Using a dummy onunload listener to disable the bfcache as that can prevent
+  // the test browser load detection mechanism from working.
+  loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.startLoadingURIString(
+    browser,
+    "data:text/html,<body%20onunload=''><iframe></iframe></body>"
+  );
+  href = await loaded;
+  is(
+    href,
+    "data:text/html,<body%20onunload=''><iframe></iframe></body>",
+    "Check data URL loaded"
+  );
+
+  loaded = BrowserTestUtils.browserLoaded(browser);
+  browser.goBack();
+  href = await loaded;
+  is(href, "about:config", "Check we've gone back to about:config");
+
+  loaded = BrowserTestUtils.browserLoaded(browser);
+  browser.goForward();
+  href = await loaded;
+  is(
+    href,
+    "data:text/html,<body%20onunload=''><iframe></iframe></body>",
+    "Check we've gone forward to data URL"
+  );
+});
diff --git a/docshell/test/browser/browser_bug1328501.js b/docshell/test/browser/browser_bug1328501.js
new file mode 100644
index 0000000000..2be74b04d0
--- /dev/null
+++ b/docshell/test/browser/browser_bug1328501.js
@@ -0,0 +1,69 @@
+const HTML_URL =
+  "http://mochi.test:8888/browser/docshell/test/browser/file_bug1328501.html";
+const FRAME_URL =
+  "http://mochi.test:8888/browser/docshell/test/browser/file_bug1328501_frame.html";
+const FRAME_SCRIPT_URL =
+  "chrome://mochitests/content/browser/docshell/test/browser/file_bug1328501_framescript.js";
+add_task(async function testMultiFrameRestore() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.navigation.requireUserInteraction", false],
+      // Disable bfcache so that dummy_page.html doesn't enter there.
+      // The actual test page does already prevent bfcache and the test
+      // is just for http-on-opening-request handling in the child process.
+      ["browser.sessionhistory.max_total_viewers", 0],
+    ],
+  });
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: HTML_URL },
+    async function (browser) {
+      // Navigate 2 subframes and load about:blank.
+      let browserLoaded = BrowserTestUtils.browserLoaded(browser);
+      await SpecialPowers.spawn(
+        browser,
+        [FRAME_URL],
+        async function (FRAME_URL) {
+          function frameLoaded(frame) {
+            frame.contentWindow.location = FRAME_URL;
+            return new Promise(r => (frame.onload = r));
+          }
+          let frame1 = content.document.querySelector("#testFrame1");
+          let frame2 = content.document.querySelector("#testFrame2");
+          ok(frame1, "check found testFrame1");
+          ok(frame2, "check found testFrame2");
+          await frameLoaded(frame1);
+          await frameLoaded(frame2);
+          content.location = "dummy_page.html";
+        }
+      );
+      await browserLoaded;
+
+      // Load a frame script to query nsIDOMWindow on "http-on-opening-request",
+      // which will force about:blank content viewers being created.
+      browser.messageManager.loadFrameScript(FRAME_SCRIPT_URL, false);
+
+      // The frame script also forwards frames-loaded.
+      let framesLoaded = BrowserTestUtils.waitForMessage(
+        browser.messageManager,
+        "test:frames-loaded"
+      );
+
+      browser.goBack();
+      await framesLoaded;
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      await new Promise(r => setTimeout(r, 1000));
+      await SpecialPowers.spawn(browser, [FRAME_URL], FRAME_URL => {
+        is(
+          content.document.querySelector("#testFrame1").contentWindow.location
+            .href,
+          FRAME_URL
+        );
+        is(
+          content.document.querySelector("#testFrame2").contentWindow.location
+            .href,
+          FRAME_URL
+        );
+      });
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1347823.js b/docshell/test/browser/browser_bug1347823.js
new file mode 100644
index 0000000000..e30706b745
--- /dev/null
+++ b/docshell/test/browser/browser_bug1347823.js
@@ -0,0 +1,91 @@
+/**
+ * Test that session history's expiration tracker would remove bfcache on
+ * expiration.
+ */
+
+// With bfcache not expired.
+add_task(async function testValidCache() {
+  // Make an unrealistic large timeout.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.sessionhistory.contentViewerTimeout", 86400],
+      // If Fission is disabled, the pref is no-op.
+      ["fission.bfcacheInParent", true],
+    ],
+  });
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "data:text/html;charset=utf-8,pageA1" },
+    async function (browser) {
+      // Make a simple modification for bfcache testing.
+      await SpecialPowers.spawn(browser, [], () => {
+        content.document.body.textContent = "modified";
+      });
+
+      // Load a random page.
+      BrowserTestUtils.startLoadingURIString(
+        browser,
+        "data:text/html;charset=utf-8,pageA2"
+      );
+      await BrowserTestUtils.browserLoaded(browser);
+
+      // Go back and verify text content.
+      let awaitPageShow = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      browser.goBack();
+      await awaitPageShow;
+      await SpecialPowers.spawn(browser, [], () => {
+        is(content.document.body.textContent, "modified");
+      });
+    }
+  );
+});
+
+// With bfcache expired.
+add_task(async function testExpiredCache() {
+  // Make bfcache timeout in 1 sec.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.sessionhistory.contentViewerTimeout", 1],
+      // If Fission is disabled, the pref is no-op.
+      ["fission.bfcacheInParent", true],
+    ],
+  });
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "data:text/html;charset=utf-8,pageB1" },
+    async function (browser) {
+      // Make a simple modification for bfcache testing.
+      await SpecialPowers.spawn(browser, [], () => {
+        content.document.body.textContent = "modified";
+      });
+
+      // Load a random page.
+      BrowserTestUtils.startLoadingURIString(
+        browser,
+        "data:text/html;charset=utf-8,pageB2"
+      );
+      await BrowserTestUtils.browserLoaded(browser);
+
+      // Wait for 3 times of expiration timeout, hopefully it's evicted...
+      await SpecialPowers.spawn(browser, [], () => {
+        return new Promise(resolve => {
+          content.setTimeout(resolve, 5000);
+        });
+      });
+
+      // Go back and verify text content.
+      let awaitPageShow = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      browser.goBack();
+      await awaitPageShow;
+      await SpecialPowers.spawn(browser, [], () => {
+        is(content.document.body.textContent, "pageB1");
+      });
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug134911.js b/docshell/test/browser/browser_bug134911.js
new file mode 100644
index 0000000000..9b52eeab47
--- /dev/null
+++ b/docshell/test/browser/browser_bug134911.js
@@ -0,0 +1,57 @@
+const TEXT = {
+  /* The test text decoded correctly as Shift_JIS */
+  rightText:
+    "\u30E6\u30CB\u30B3\u30FC\u30C9\u306F\u3001\u3059\u3079\u3066\u306E\u6587\u5B57\u306B\u56FA\u6709\u306E\u756A\u53F7\u3092\u4ED8\u4E0E\u3057\u307E\u3059",
+
+  enteredText1: "The quick brown fox jumps over the lazy dog",
+  enteredText2:
+    "\u03BE\u03B5\u03C3\u03BA\u03B5\u03C0\u03AC\u03B6\u03C9\u0020\u03C4\u1F74\u03BD\u0020\u03C8\u03C5\u03C7\u03BF\u03C6\u03B8\u03CC\u03C1\u03B1\u0020\u03B2\u03B4\u03B5\u03BB\u03C5\u03B3\u03BC\u03AF\u03B1",
+};
+
+function test() {
+  waitForExplicitFinish();
+
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  gBrowser.selectedTab = BrowserTestUtils.addTab(
+    gBrowser,
+    rootDir + "test-form_sjis.html"
+  );
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(afterOpen);
+}
+
+function afterOpen() {
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(
+    afterChangeCharset
+  );
+
+  SpecialPowers.spawn(gBrowser.selectedBrowser, [TEXT], function (TEXT) {
+    content.document.getElementById("testtextarea").value = TEXT.enteredText1;
+    content.document.getElementById("testinput").value = TEXT.enteredText2;
+  }).then(() => {
+    /* Force the page encoding to Shift_JIS */
+    BrowserForceEncodingDetection();
+  });
+}
+
+function afterChangeCharset() {
+  SpecialPowers.spawn(gBrowser.selectedBrowser, [TEXT], function (TEXT) {
+    is(
+      content.document.getElementById("testpar").innerHTML,
+      TEXT.rightText,
+      "encoding successfully changed"
+    );
+    is(
+      content.document.getElementById("testtextarea").value,
+      TEXT.enteredText1,
+      "text preserved in <textarea>"
+    );
+    is(
+      content.document.getElementById("testinput").value,
+      TEXT.enteredText2,
+      "text preserved in <input>"
+    );
+  }).then(() => {
+    gBrowser.removeCurrentTab();
+    finish();
+  });
+}
diff --git a/docshell/test/browser/browser_bug1415918_beforeunload_options.js b/docshell/test/browser/browser_bug1415918_beforeunload_options.js
new file mode 100644
index 0000000000..627abd90ba
--- /dev/null
+++ b/docshell/test/browser/browser_bug1415918_beforeunload_options.js
@@ -0,0 +1,162 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com"
+);
+
+const { PromptTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PromptTestUtils.sys.mjs"
+);
+
+SimpleTest.requestFlakyTimeout("Needs to test a timeout");
+
+function delay(msec) {
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  return new Promise(resolve => setTimeout(resolve, msec));
+}
+
+function allowNextNavigation(browser) {
+  return PromptTestUtils.handleNextPrompt(
+    browser,
+    { modalType: Services.prompt.MODAL_TYPE_CONTENT, promptType: "confirmEx" },
+    { buttonNumClick: 0 }
+  );
+}
+
+function cancelNextNavigation(browser) {
+  return PromptTestUtils.handleNextPrompt(
+    browser,
+    { modalType: Services.prompt.MODAL_TYPE_CONTENT, promptType: "confirmEx" },
+    { buttonNumClick: 1 }
+  );
+}
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.require_user_interaction_for_beforeunload", false]],
+  });
+
+  const permitUnloadTimeout = Services.prefs.getIntPref(
+    "dom.beforeunload_timeout_ms"
+  );
+
+  let url = TEST_PATH + "dummy_page.html";
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
+  let browser = tab.linkedBrowser;
+
+  await SpecialPowers.spawn(browser.browsingContext, [], () => {
+    content.addEventListener("beforeunload", event => {
+      event.preventDefault();
+    });
+  });
+
+  /*
+   * Check condition where beforeunload handlers request a prompt.
+   */
+
+  // Prompt is shown, user clicks OK.
+
+  let promptShownPromise = allowNextNavigation(browser);
+  ok(browser.permitUnload().permitUnload, "permit unload should be true");
+  await promptShownPromise;
+
+  // Prompt is shown, user clicks CANCEL.
+  promptShownPromise = cancelNextNavigation(browser);
+  ok(!browser.permitUnload().permitUnload, "permit unload should be false");
+  await promptShownPromise;
+
+  // Prompt is not shown, don't permit unload.
+  let promptShown = false;
+  let shownCallback = () => {
+    promptShown = true;
+  };
+
+  browser.addEventListener("DOMWillOpenModalDialog", shownCallback);
+  ok(
+    !browser.permitUnload("dontUnload").permitUnload,
+    "permit unload should be false"
+  );
+  ok(!promptShown, "prompt should not have been displayed");
+
+  // Prompt is not shown, permit unload.
+  promptShown = false;
+  ok(
+    browser.permitUnload("unload").permitUnload,
+    "permit unload should be true"
+  );
+  ok(!promptShown, "prompt should not have been displayed");
+  browser.removeEventListener("DOMWillOpenModalDialog", shownCallback);
+
+  promptShownPromise = PromptTestUtils.waitForPrompt(browser, {
+    modalType: Services.prompt.MODAL_TYPE_CONTENT,
+    promptType: "confirmEx",
+  });
+
+  let promptDismissed = false;
+  let closedCallback = () => {
+    promptDismissed = true;
+  };
+
+  browser.addEventListener("DOMModalDialogClosed", closedCallback);
+
+  let promise = browser.asyncPermitUnload();
+
+  let promiseResolved = false;
+  promise.then(() => {
+    promiseResolved = true;
+  });
+
+  let dialog = await promptShownPromise;
+  ok(!promiseResolved, "Should not have resolved promise yet");
+
+  await delay(permitUnloadTimeout * 1.5);
+
+  ok(!promptDismissed, "Should not have dismissed prompt yet");
+  ok(!promiseResolved, "Should not have resolved promise yet");
+
+  await PromptTestUtils.handlePrompt(dialog, { buttonNumClick: 1 });
+
+  let { permitUnload } = await promise;
+  ok(promptDismissed, "Should have dismissed prompt");
+  ok(!permitUnload, "Should not have permitted unload");
+
+  browser.removeEventListener("DOMModalDialogClosed", closedCallback);
+
+  promptShownPromise = allowNextNavigation(browser);
+
+  /*
+   * Check condition where no one requests a prompt.  In all cases,
+   * permitUnload should be true, and all handlers fired.
+   */
+  url += "?1";
+  BrowserTestUtils.startLoadingURIString(browser, url);
+  await BrowserTestUtils.browserLoaded(browser, false, url);
+  await promptShownPromise;
+
+  promptShown = false;
+  browser.addEventListener("DOMWillOpenModalDialog", shownCallback);
+
+  ok(browser.permitUnload().permitUnload, "permit unload should be true");
+  ok(!promptShown, "prompt should not have been displayed");
+
+  promptShown = false;
+  ok(
+    browser.permitUnload("dontUnload").permitUnload,
+    "permit unload should be true"
+  );
+  ok(!promptShown, "prompt should not have been displayed");
+
+  promptShown = false;
+  ok(
+    browser.permitUnload("unload").permitUnload,
+    "permit unload should be true"
+  );
+  ok(!promptShown, "prompt should not have been displayed");
+
+  browser.removeEventListener("DOMWillOpenModalDialog", shownCallback);
+
+  await BrowserTestUtils.removeTab(tab, { skipPermitUnload: true });
+});
diff --git a/docshell/test/browser/browser_bug1543077-3.js b/docshell/test/browser/browser_bug1543077-3.js
new file mode 100644
index 0000000000..7cef4aef10
--- /dev/null
+++ b/docshell/test/browser/browser_bug1543077-3.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1543077-3.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u3042"),
+    136,
+    "Parent doc should be ISO-2022-JP initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u3042"),
+    92,
+    "Child doc should be ISO-2022-JP initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u3042"),
+    136,
+    "Parent doc should decode as ISO-2022-JP subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u3042"),
+    92,
+    "Child doc should decode as ISO-2022-JP subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "ISO-2022-JP",
+    "Parent doc should report ISO-2022-JP subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "ISO-2022-JP",
+    "Child doc should report ISO-2022-JP subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1594938.js b/docshell/test/browser/browser_bug1594938.js
new file mode 100644
index 0000000000..569afe6901
--- /dev/null
+++ b/docshell/test/browser/browser_bug1594938.js
@@ -0,0 +1,100 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test for Bug 1594938
+ *
+ * If a session history listener blocks reloads we shouldn't crash.
+ */
+
+add_task(async function test() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "https://example.com/" },
+    async function (browser) {
+      if (!SpecialPowers.Services.appinfo.sessionHistoryInParent) {
+        await SpecialPowers.spawn(browser, [], async function () {
+          let history = this.content.docShell.QueryInterface(
+            Ci.nsIWebNavigation
+          ).sessionHistory;
+
+          let testDone = {};
+          testDone.promise = new Promise(resolve => {
+            testDone.resolve = resolve;
+          });
+
+          let listenerCalled = false;
+          let listener = {
+            OnHistoryNewEntry: aNewURI => {},
+            OnHistoryReload: () => {
+              listenerCalled = true;
+              this.content.setTimeout(() => {
+                testDone.resolve();
+              });
+              return false;
+            },
+            OnHistoryGotoIndex: () => {},
+            OnHistoryPurge: () => {},
+            OnHistoryReplaceEntry: () => {},
+
+            QueryInterface: ChromeUtils.generateQI([
+              "nsISHistoryListener",
+              "nsISupportsWeakReference",
+            ]),
+          };
+
+          history.legacySHistory.addSHistoryListener(listener);
+
+          history.reload(Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE);
+          await testDone.promise;
+
+          Assert.ok(listenerCalled, "reloads were blocked");
+
+          history.legacySHistory.removeSHistoryListener(listener);
+        });
+
+        return;
+      }
+
+      let history = browser.browsingContext.sessionHistory;
+
+      let testDone = {};
+      testDone.promise = new Promise(resolve => {
+        testDone.resolve = resolve;
+      });
+
+      let listenerCalled = false;
+      let listener = {
+        OnHistoryNewEntry: aNewURI => {},
+        OnHistoryReload: () => {
+          listenerCalled = true;
+          setTimeout(() => {
+            testDone.resolve();
+          });
+          return false;
+        },
+        OnHistoryGotoIndex: () => {},
+        OnHistoryPurge: () => {},
+        OnHistoryReplaceEntry: () => {},
+
+        QueryInterface: ChromeUtils.generateQI([
+          "nsISHistoryListener",
+          "nsISupportsWeakReference",
+        ]),
+      };
+
+      history.addSHistoryListener(listener);
+
+      await SpecialPowers.spawn(browser, [], () => {
+        let history = this.content.docShell.QueryInterface(
+          Ci.nsIWebNavigation
+        ).sessionHistory;
+        history.reload(Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE);
+      });
+      await testDone.promise;
+
+      Assert.ok(listenerCalled, "reloads were blocked");
+
+      history.removeSHistoryListener(listener);
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1622420.js b/docshell/test/browser/browser_bug1622420.js
new file mode 100644
index 0000000000..81026611e4
--- /dev/null
+++ b/docshell/test/browser/browser_bug1622420.js
@@ -0,0 +1,31 @@
+const ACTOR = "Bug1622420";
+
+add_task(async function test() {
+  let base = getRootDirectory(gTestPath).slice(0, -1);
+  ChromeUtils.registerWindowActor(ACTOR, {
+    allFrames: true,
+    child: {
+      esModuleURI: `${base}/Bug1622420Child.sys.mjs`,
+    },
+  });
+
+  registerCleanupFunction(async () => {
+    gBrowser.removeTab(tab);
+
+    ChromeUtils.unregisterWindowActor(ACTOR);
+  });
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.org/browser/docshell/test/browser/file_bug1622420.html"
+  );
+  let childBC = tab.linkedBrowser.browsingContext.children[0];
+  let success = await childBC.currentWindowGlobal
+    .getActor(ACTOR)
+    .sendQuery("hasWindowContextForTopBC");
+  ok(
+    success,
+    "Should have a WindowContext for the top BrowsingContext in the process of a child BrowsingContext"
+  );
+});
diff --git a/docshell/test/browser/browser_bug1648464-1.js b/docshell/test/browser/browser_bug1648464-1.js
new file mode 100644
index 0000000000..c2a8093a3d
--- /dev/null
+++ b/docshell/test/browser/browser_bug1648464-1.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1648464-1.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u00A4"),
+    146,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u00A4"),
+    95,
+    "Child doc should be windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u3042"),
+    146,
+    "Parent doc should decode as EUC-JP subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u3042"),
+    95,
+    "Child doc should decode as EUC-JP subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "EUC-JP",
+    "Parent doc should report EUC-JP subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "EUC-JP",
+    "Child doc should report EUC-JP subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1673702.js b/docshell/test/browser/browser_bug1673702.js
new file mode 100644
index 0000000000..c32c38fe45
--- /dev/null
+++ b/docshell/test/browser/browser_bug1673702.js
@@ -0,0 +1,27 @@
+const DUMMY =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.org/browser/docshell/test/browser/dummy_page.html";
+const JSON =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com/browser/docshell/test/browser/file_bug1673702.json";
+
+add_task(async function test_backAndReload() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: DUMMY },
+    async function (browser) {
+      info("Start JSON load.");
+      BrowserTestUtils.startLoadingURIString(browser, JSON);
+      await BrowserTestUtils.waitForLocationChange(gBrowser, JSON);
+
+      info("JSON load has started, go back.");
+      browser.goBack();
+      await BrowserTestUtils.browserStopped(browser);
+
+      info("Reload.");
+      BrowserReload();
+      await BrowserTestUtils.waitForLocationChange(gBrowser);
+
+      is(browser.documentURI.spec, DUMMY);
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1674464.js b/docshell/test/browser/browser_bug1674464.js
new file mode 100644
index 0000000000..ff9e990a40
--- /dev/null
+++ b/docshell/test/browser/browser_bug1674464.js
@@ -0,0 +1,38 @@
+const DUMMY_1 =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.org/browser/docshell/test/browser/dummy_page.html";
+const DUMMY_2 =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com/browser/docshell/test/browser/dummy_page.html";
+
+add_task(async function test_backAndReload() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: DUMMY_1 },
+    async function (browser) {
+      await BrowserTestUtils.crashFrame(browser);
+
+      info("Start second load.");
+      BrowserTestUtils.startLoadingURIString(browser, DUMMY_2);
+      await BrowserTestUtils.waitForLocationChange(gBrowser, DUMMY_2);
+
+      browser.goBack();
+      await BrowserTestUtils.waitForLocationChange(gBrowser);
+
+      is(
+        browser.browsingContext.childSessionHistory.index,
+        0,
+        "We should have gone back to the first page"
+      );
+      is(
+        browser.browsingContext.childSessionHistory.count,
+        2,
+        "If a tab crashes after a load has finished we shouldn't have an entry for about:tabcrashed"
+      );
+      is(
+        browser.documentURI.spec,
+        DUMMY_1,
+        "If a tab crashes after a load has finished we shouldn't have an entry for about:tabcrashed"
+      );
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1688368-1.js b/docshell/test/browser/browser_bug1688368-1.js
new file mode 100644
index 0000000000..04fc3dd9a8
--- /dev/null
+++ b/docshell/test/browser/browser_bug1688368-1.js
@@ -0,0 +1,24 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1688368-1.sjs",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.body.textContent.indexOf("Γ’"),
+    0,
+    "Doc should be windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.body.textContent.indexOf("β˜ƒ"),
+    0,
+    "Doc should be UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1691153.js b/docshell/test/browser/browser_bug1691153.js
new file mode 100644
index 0000000000..ed4969dae8
--- /dev/null
+++ b/docshell/test/browser/browser_bug1691153.js
@@ -0,0 +1,73 @@
+"use strict";
+
+add_task(async () => {
+  const TEST_PATH = getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.com"
+  );
+
+  const HTML_URI = TEST_PATH + "file_bug1691153.html";
+
+  // Opening the page that contains the iframe
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+  let browser = tab.linkedBrowser;
+  let browserLoaded = BrowserTestUtils.browserLoaded(
+    browser,
+    true,
+    HTML_URI,
+    true
+  );
+  info("new tab loaded");
+
+  BrowserTestUtils.startLoadingURIString(browser, HTML_URI);
+  await browserLoaded;
+  info("The test page has loaded!");
+
+  let first_message_promise = SpecialPowers.spawn(
+    browser,
+    [],
+    async function () {
+      let blobPromise = new Promise((resolve, reject) => {
+        content.addEventListener("message", event => {
+          if (event.data.bloburl) {
+            info("Sanity check: recvd blob URL as " + event.data.bloburl);
+            resolve(event.data.bloburl);
+          }
+        });
+      });
+      content.postMessage("getblob", "*");
+      return blobPromise;
+    }
+  );
+  info("The test page has loaded!");
+  let blob_url = await first_message_promise;
+
+  Assert.ok(blob_url.startsWith("blob:"), "Sanity check: recvd blob");
+  info(`Received blob URL message from content: ${blob_url}`);
+  // try to open the blob in a new tab, manually created by the user
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    blob_url,
+    true,
+    false,
+    true
+  );
+
+  let principal = gBrowser.selectedTab.linkedBrowser._contentPrincipal;
+  Assert.ok(
+    !principal.isSystemPrincipal,
+    "Newly opened blob shouldn't be Systemprincipal"
+  );
+  Assert.ok(
+    !principal.isExpandedPrincipal,
+    "Newly opened blob shouldn't be ExpandedPrincipal"
+  );
+  Assert.ok(
+    principal.isContentPrincipal,
+    "Newly opened blob tab should be ContentPrincipal"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(tab2);
+});
diff --git a/docshell/test/browser/browser_bug1705872.js b/docshell/test/browser/browser_bug1705872.js
new file mode 100644
index 0000000000..87d10b4526
--- /dev/null
+++ b/docshell/test/browser/browser_bug1705872.js
@@ -0,0 +1,74 @@
+"use strict";
+
+async function doLoadAndGoBack(browser, ext) {
+  let loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.startLoadingURIString(browser, "https://example.com/");
+  await ext.awaitMessage("redir-handled");
+  await loaded;
+
+  let pageShownPromise = BrowserTestUtils.waitForContentEvent(
+    browser,
+    "pageshow",
+    true
+  );
+  await SpecialPowers.spawn(browser, [], () => {
+    content.history.back();
+  });
+  return pageShownPromise;
+}
+
+add_task(async function test_back() {
+  let extension = ExtensionTestUtils.loadExtension({
+    manifest: {
+      permissions: ["webRequest", "webRequestBlocking", "https://example.com/"],
+      web_accessible_resources: ["test.html"],
+    },
+    files: {
+      "test.html":
+        "<!DOCTYPE html><html><head><title>Test add-on</title></head><body></body></html>",
+    },
+    background: () => {
+      let { browser } = this;
+      browser.webRequest.onHeadersReceived.addListener(
+        details => {
+          if (details.statusCode != 200) {
+            return undefined;
+          }
+          browser.test.sendMessage("redir-handled");
+          return { redirectUrl: browser.runtime.getURL("test.html") };
+        },
+        {
+          urls: ["https://example.com/"],
+          types: ["main_frame"],
+        },
+        ["blocking"]
+      );
+    },
+  });
+
+  await extension.startup();
+
+  await BrowserTestUtils.withNewTab("about:home", async function (browser) {
+    await doLoadAndGoBack(browser, extension);
+
+    await SpecialPowers.spawn(browser, [], () => {
+      is(
+        content.document.documentURI,
+        "about:home",
+        "Gone back to the right page"
+      );
+    });
+
+    await doLoadAndGoBack(browser, extension);
+
+    await SpecialPowers.spawn(browser, [], () => {
+      is(
+        content.document.documentURI,
+        "about:home",
+        "Gone back to the right page"
+      );
+    });
+  });
+
+  await extension.unload();
+});
diff --git a/docshell/test/browser/browser_bug1716290-1.js b/docshell/test/browser/browser_bug1716290-1.js
new file mode 100644
index 0000000000..48add6f0eb
--- /dev/null
+++ b/docshell/test/browser/browser_bug1716290-1.js
@@ -0,0 +1,24 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1716290-1.sjs",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.characterSet,
+    "Shift_JIS",
+    "Doc should report Shift_JIS initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Doc should report windows-1252 subsequently (detector should override header)"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1716290-2.js b/docshell/test/browser/browser_bug1716290-2.js
new file mode 100644
index 0000000000..a33c61f076
--- /dev/null
+++ b/docshell/test/browser/browser_bug1716290-2.js
@@ -0,0 +1,24 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1716290-2.sjs",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.characterSet,
+    "Shift_JIS",
+    "Doc should report Shift_JIS initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Doc should report windows-1252 subsequently (detector should override meta resolving to the replacement encoding)"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1716290-3.js b/docshell/test/browser/browser_bug1716290-3.js
new file mode 100644
index 0000000000..f7e6ca5bbd
--- /dev/null
+++ b/docshell/test/browser/browser_bug1716290-3.js
@@ -0,0 +1,24 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1716290-3.sjs",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.characterSet,
+    "Shift_JIS",
+    "Doc should report Shift_JIS initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.characterSet,
+    "replacement",
+    "Doc should report replacement subsequently (non-ASCII-compatible HTTP header should override detector)"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1716290-4.js b/docshell/test/browser/browser_bug1716290-4.js
new file mode 100644
index 0000000000..ab0d46d7ff
--- /dev/null
+++ b/docshell/test/browser/browser_bug1716290-4.js
@@ -0,0 +1,24 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1716290-4.sjs",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.characterSet,
+    "Shift_JIS",
+    "Doc should report Shift_JIS initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.characterSet,
+    "UTF-16BE",
+    "Doc should report UTF-16BE subsequently (BOM should override detector)"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1719178.js b/docshell/test/browser/browser_bug1719178.js
new file mode 100644
index 0000000000..6c4fc2d15f
--- /dev/null
+++ b/docshell/test/browser/browser_bug1719178.js
@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+SimpleTest.requestFlakyTimeout(
+  "The test needs to let objects die asynchronously."
+);
+
+add_task(async function test_accessing_shistory() {
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:preferences"
+  );
+  let sh = tab.linkedBrowser.browsingContext.sessionHistory;
+  ok(sh, "Should have SessionHistory object");
+  gBrowser.removeTab(tab);
+  tab = null;
+  for (let i = 0; i < 5; ++i) {
+    SpecialPowers.Services.obs.notifyObservers(
+      null,
+      "memory-pressure",
+      "heap-minimize"
+    );
+    SpecialPowers.DOMWindowUtils.garbageCollect();
+    await new Promise(function (r) {
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      setTimeout(r, 50);
+    });
+  }
+
+  try {
+    sh.reloadCurrentEntry();
+  } catch (ex) {}
+  ok(true, "This test shouldn't crash.");
+});
diff --git a/docshell/test/browser/browser_bug1736248-1.js b/docshell/test/browser/browser_bug1736248-1.js
new file mode 100644
index 0000000000..d9cbe4fd85
--- /dev/null
+++ b/docshell/test/browser/browser_bug1736248-1.js
@@ -0,0 +1,34 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug1736248-1.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u00C3"),
+    1064,
+    "Doc should be windows-1252 initially"
+  );
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Doc should report windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u00E4"),
+    1064,
+    "Doc should be UTF-8 subsequently"
+  );
+  is(
+    content.document.characterSet,
+    "UTF-8",
+    "Doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug1757005.js b/docshell/test/browser/browser_bug1757005.js
new file mode 100644
index 0000000000..6b257a9115
--- /dev/null
+++ b/docshell/test/browser/browser_bug1757005.js
@@ -0,0 +1,73 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function () {
+  // (1) Load one page with bfcache disabled and another one with bfcache enabled.
+  // (2) Check that BrowsingContext.getCurrentTopByBrowserId(browserId) returns
+  //     the expected browsing context both in the parent process and in the child process.
+  // (3) Go back and then forward
+  // (4) Run the same checks as in step 2 again.
+
+  let url1 = "data:text/html,<body onunload='/* disable bfcache */'>";
+  let url2 = "data:text/html,page2";
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: url1,
+    },
+    async function (browser) {
+      info("Initial load");
+
+      let loaded = BrowserTestUtils.browserLoaded(browser);
+      BrowserTestUtils.startLoadingURIString(browser, url2);
+      await loaded;
+      info("Second page loaded");
+
+      let browserId = browser.browserId;
+      ok(!!browser.browsingContext, "Should have a BrowsingContext. (1)");
+      is(
+        BrowsingContext.getCurrentTopByBrowserId(browserId),
+        browser.browsingContext,
+        "Should get the correct browsingContext(1)"
+      );
+
+      await ContentTask.spawn(browser, browserId, async function (browserId) {
+        Assert.ok(
+          BrowsingContext.getCurrentTopByBrowserId(browserId) ==
+            docShell.browsingContext
+        );
+        Assert.ok(docShell.browsingContext.browserId == browserId);
+      });
+
+      let awaitPageShow = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      browser.goBack();
+      await awaitPageShow;
+      info("Back");
+
+      awaitPageShow = BrowserTestUtils.waitForContentEvent(browser, "pageshow");
+      browser.goForward();
+      await awaitPageShow;
+      info("Forward");
+
+      ok(!!browser.browsingContext, "Should have a BrowsingContext. (2)");
+      is(
+        BrowsingContext.getCurrentTopByBrowserId(browserId),
+        browser.browsingContext,
+        "Should get the correct BrowsingContext. (2)"
+      );
+
+      await ContentTask.spawn(browser, browserId, async function (browserId) {
+        Assert.ok(
+          BrowsingContext.getCurrentTopByBrowserId(browserId) ==
+            docShell.browsingContext
+        );
+        Assert.ok(docShell.browsingContext.browserId == browserId);
+      });
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1769189.js b/docshell/test/browser/browser_bug1769189.js
new file mode 100644
index 0000000000..08cb4f9002
--- /dev/null
+++ b/docshell/test/browser/browser_bug1769189.js
@@ -0,0 +1,32 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_beforeUnload_and_replaceState() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "data:text/html,<script>window.addEventListener('beforeunload', () => { window.history.replaceState(true, ''); });</script>",
+    },
+    async function (browser) {
+      let initialState = await SpecialPowers.spawn(browser, [], () => {
+        return content.history.state;
+      });
+
+      is(initialState, null, "history.state should be initially null.");
+
+      let awaitPageShow = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      BrowserReload();
+      await awaitPageShow;
+
+      let updatedState = await SpecialPowers.spawn(browser, [], () => {
+        return content.history.state;
+      });
+      is(updatedState, true, "history.state should have been updated.");
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug1798780.js b/docshell/test/browser/browser_bug1798780.js
new file mode 100644
index 0000000000..a9ad16ee35
--- /dev/null
+++ b/docshell/test/browser/browser_bug1798780.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// The test loads an initial page and then another page which does enough
+// fragment navigations so that when going back to the initial page and then
+// forward to the last page, the initial page is evicted from the bfcache.
+add_task(async function testBFCacheEviction() {
+  // Make an unrealistic large timeout.
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.sessionhistory.contentViewerTimeout", 86400]],
+  });
+
+  const uri = "data:text/html,initial page";
+  const uri2 =
+    getRootDirectory(gTestPath).replace(
+      "chrome://mochitests/content",
+      "https://example.com"
+    ) + "dummy_page.html";
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: uri },
+    async function (browser) {
+      BrowserTestUtils.startLoadingURIString(browser, uri2);
+      await BrowserTestUtils.browserLoaded(browser);
+
+      let awaitPageShow = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      await SpecialPowers.spawn(browser, [], async function () {
+        content.location.hash = "1";
+        content.location.hash = "2";
+        content.location.hash = "3";
+        content.history.go(-4);
+      });
+
+      await awaitPageShow;
+
+      let awaitPageShow2 = BrowserTestUtils.waitForContentEvent(
+        browser,
+        "pageshow"
+      );
+      await SpecialPowers.spawn(browser, [], async function () {
+        content.history.go(4);
+      });
+      await awaitPageShow2;
+      ok(true, "Didn't time out.");
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug234628-1.js b/docshell/test/browser/browser_bug234628-1.js
new file mode 100644
index 0000000000..566da65bca
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-1.js
@@ -0,0 +1,47 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-1.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    129,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    85,
+    "Child doc should be windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    129,
+    "Parent doc should be windows-1252 subsequently"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    85,
+    "Child doc should be windows-1252 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "windows-1252",
+    "Child doc should report windows-1252 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-10.js b/docshell/test/browser/browser_bug234628-10.js
new file mode 100644
index 0000000000..8fb51cf27c
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-10.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-10.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    151,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    71,
+    "Child doc should be utf-8 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    151,
+    "Parent doc should be windows-1252 initially"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    71,
+    "Child doc should decode as utf-8 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-8",
+    "Child doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-11.js b/docshell/test/browser/browser_bug234628-11.js
new file mode 100644
index 0000000000..d11645ff76
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-11.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-11.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    193,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    107,
+    "Child doc should be utf-8 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    193,
+    "Parent doc should be windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    107,
+    "Child doc should decode as utf-8 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-8",
+    "Child doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-2.js b/docshell/test/browser/browser_bug234628-2.js
new file mode 100644
index 0000000000..da93dc2ac2
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-2.js
@@ -0,0 +1,49 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-2.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    129,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf(
+      "\u00E2\u201A\u00AC"
+    ),
+    78,
+    "Child doc should be windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    129,
+    "Parent doc should be windows-1252 subsequently"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    78,
+    "Child doc should be UTF-8 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-8",
+    "Child doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-3.js b/docshell/test/browser/browser_bug234628-3.js
new file mode 100644
index 0000000000..8a143b51a6
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-3.js
@@ -0,0 +1,47 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-3.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    118,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    73,
+    "Child doc should be utf-8 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    118,
+    "Parent doc should be windows-1252 subsequently"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    73,
+    "Child doc should be utf-8 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-8",
+    "Child doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-4.js b/docshell/test/browser/browser_bug234628-4.js
new file mode 100644
index 0000000000..19ec0f8dbf
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-4.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-4.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    132,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    79,
+    "Child doc should be utf-8 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    132,
+    "Parent doc should decode as windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    79,
+    "Child doc should decode as utf-8 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-8",
+    "Child doc should report UTF-8 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-5.js b/docshell/test/browser/browser_bug234628-5.js
new file mode 100644
index 0000000000..77753ed78d
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-5.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-5.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    146,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    87,
+    "Child doc should be utf-16 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    146,
+    "Parent doc should be windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    87,
+    "Child doc should decode as utf-16 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-16LE",
+    "Child doc should report UTF-16LE subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-6.js b/docshell/test/browser/browser_bug234628-6.js
new file mode 100644
index 0000000000..88ff6c1a82
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-6.js
@@ -0,0 +1,47 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug234628-6.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    190,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    109,
+    "Child doc should be utf-16 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    190,
+    "Parent doc should be windows-1252 subsequently"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    109,
+    "Child doc should be utf-16 subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "windows-1252",
+    "Parent doc should report windows-1252 subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "UTF-16BE",
+    "Child doc should report UTF-16 subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-8.js b/docshell/test/browser/browser_bug234628-8.js
new file mode 100644
index 0000000000..024a3d4d64
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-8.js
@@ -0,0 +1,18 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetCheck(rootDir + "file_bug234628-8.html", afterOpen);
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u0402"),
+    156,
+    "Parent doc should be windows-1251"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u0402"),
+    99,
+    "Child doc should be windows-1251"
+  );
+}
diff --git a/docshell/test/browser/browser_bug234628-9.js b/docshell/test/browser/browser_bug234628-9.js
new file mode 100644
index 0000000000..ceb7dc4e63
--- /dev/null
+++ b/docshell/test/browser/browser_bug234628-9.js
@@ -0,0 +1,18 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetCheck(rootDir + "file_bug234628-9.html", afterOpen);
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u20AC"),
+    145,
+    "Parent doc should be UTF-16"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u20AC"),
+    96,
+    "Child doc should be windows-1252"
+  );
+}
diff --git a/docshell/test/browser/browser_bug349769.js b/docshell/test/browser/browser_bug349769.js
new file mode 100644
index 0000000000..33fca715cf
--- /dev/null
+++ b/docshell/test/browser/browser_bug349769.js
@@ -0,0 +1,79 @@
+add_task(async function test() {
+  const uris = [undefined, "about:blank"];
+
+  function checkContentProcess(newBrowser, uri) {
+    return ContentTask.spawn(newBrowser, [uri], async function (uri) {
+      var prin = content.document.nodePrincipal;
+      Assert.notEqual(
+        prin,
+        null,
+        "Loaded principal must not be null when adding " + uri
+      );
+      Assert.notEqual(
+        prin,
+        undefined,
+        "Loaded principal must not be undefined when loading " + uri
+      );
+
+      Assert.equal(
+        prin.isSystemPrincipal,
+        false,
+        "Loaded principal must not be system when loading " + uri
+      );
+    });
+  }
+
+  for (var uri of uris) {
+    await BrowserTestUtils.withNewTab(
+      { gBrowser },
+      async function (newBrowser) {
+        let loadedPromise = BrowserTestUtils.browserLoaded(newBrowser);
+        BrowserTestUtils.startLoadingURIString(newBrowser, uri);
+
+        var prin = newBrowser.contentPrincipal;
+        isnot(
+          prin,
+          null,
+          "Forced principal must not be null when loading " + uri
+        );
+        isnot(
+          prin,
+          undefined,
+          "Forced principal must not be undefined when loading " + uri
+        );
+        is(
+          prin.isSystemPrincipal,
+          false,
+          "Forced principal must not be system when loading " + uri
+        );
+
+        // Belt-and-suspenders e10s check: make sure that the same checks hold
+        // true in the content process.
+        await checkContentProcess(newBrowser, uri);
+
+        await loadedPromise;
+
+        prin = newBrowser.contentPrincipal;
+        isnot(
+          prin,
+          null,
+          "Loaded principal must not be null when adding " + uri
+        );
+        isnot(
+          prin,
+          undefined,
+          "Loaded principal must not be undefined when loading " + uri
+        );
+        is(
+          prin.isSystemPrincipal,
+          false,
+          "Loaded principal must not be system when loading " + uri
+        );
+
+        // Belt-and-suspenders e10s check: make sure that the same checks hold
+        // true in the content process.
+        await checkContentProcess(newBrowser, uri);
+      }
+    );
+  }
+});
diff --git a/docshell/test/browser/browser_bug388121-1.js b/docshell/test/browser/browser_bug388121-1.js
new file mode 100644
index 0000000000..07c476f11b
--- /dev/null
+++ b/docshell/test/browser/browser_bug388121-1.js
@@ -0,0 +1,22 @@
+add_task(async function test() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function (newBrowser) {
+      await SpecialPowers.spawn(newBrowser, [], async function () {
+        var prin = content.document.nodePrincipal;
+        Assert.notEqual(prin, null, "Loaded principal must not be null");
+        Assert.notEqual(
+          prin,
+          undefined,
+          "Loaded principal must not be undefined"
+        );
+
+        Assert.equal(
+          prin.isSystemPrincipal,
+          false,
+          "Loaded principal must not be system"
+        );
+      });
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug388121-2.js b/docshell/test/browser/browser_bug388121-2.js
new file mode 100644
index 0000000000..695ff1079c
--- /dev/null
+++ b/docshell/test/browser/browser_bug388121-2.js
@@ -0,0 +1,74 @@
+function test() {
+  waitForExplicitFinish();
+
+  var w;
+  var iteration = 1;
+  const uris = ["", "about:blank"];
+  var uri;
+  var origWgp;
+
+  function testLoad() {
+    let wgp = w.gBrowser.selectedBrowser.browsingContext.currentWindowGlobal;
+    if (wgp == origWgp) {
+      // Go back to polling
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      setTimeout(testLoad, 10);
+      return;
+    }
+    var prin = wgp.documentPrincipal;
+    isnot(prin, null, "Loaded principal must not be null when adding " + uri);
+    isnot(
+      prin,
+      undefined,
+      "Loaded principal must not be undefined when loading " + uri
+    );
+    is(
+      prin.isSystemPrincipal,
+      false,
+      "Loaded principal must not be system when loading " + uri
+    );
+    w.close();
+
+    if (iteration == uris.length) {
+      finish();
+    } else {
+      ++iteration;
+      doTest();
+    }
+  }
+
+  function doTest() {
+    uri = uris[iteration - 1];
+    window.open(uri, "_blank", "width=10,height=10,noopener");
+    w = Services.wm.getMostRecentWindow("navigator:browser");
+    origWgp = w.gBrowser.selectedBrowser.browsingContext.currentWindowGlobal;
+    var prin = origWgp.documentPrincipal;
+    if (!uri) {
+      uri = undefined;
+    }
+    isnot(prin, null, "Forced principal must not be null when loading " + uri);
+    isnot(
+      prin,
+      undefined,
+      "Forced principal must not be undefined when loading " + uri
+    );
+    is(
+      prin.isSystemPrincipal,
+      false,
+      "Forced principal must not be system when loading " + uri
+    );
+    if (uri == undefined) {
+      // No actual load here, so just move along.
+      w.close();
+      ++iteration;
+      doTest();
+    } else {
+      // Need to poll, because load listeners on the content window won't
+      // survive the load.
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      setTimeout(testLoad, 10);
+    }
+  }
+
+  doTest();
+}
diff --git a/docshell/test/browser/browser_bug420605.js b/docshell/test/browser/browser_bug420605.js
new file mode 100644
index 0000000000..152d4faedb
--- /dev/null
+++ b/docshell/test/browser/browser_bug420605.js
@@ -0,0 +1,131 @@
+/* Test for Bug 420605
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=420605
+ */
+
+const { PlacesTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PlacesTestUtils.sys.mjs"
+);
+
+add_task(async function test() {
+  var pageurl =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_bug420605.html";
+  var fragmenturl =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_bug420605.html#firefox";
+
+  /* Queries nsINavHistoryService and returns a single history entry
+   * for a given URI */
+  function getNavHistoryEntry(aURI) {
+    var options = PlacesUtils.history.getNewQueryOptions();
+    options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_HISTORY;
+    options.maxResults = 1;
+
+    var query = PlacesUtils.history.getNewQuery();
+    query.uri = aURI;
+    var result = PlacesUtils.history.executeQuery(query, options);
+    result.root.containerOpen = true;
+
+    if (!result.root.childCount) {
+      return null;
+    }
+    return result.root.getChild(0);
+  }
+
+  // We'll save the favicon URL of the orignal page here and check that the
+  // page with a hash has the same favicon.
+  var originalFavicon;
+
+  // Control flow in this test is a bit complicated.
+  //
+  // When the page loads, onPageLoad (the DOMContentLoaded handler) and
+  // favicon-changed are both called, in some order.  Once
+  // they've both run, we click a fragment link in the content page
+  // (clickLinkIfReady), which should trigger another favicon-changed event,
+  // this time for the fragment's URL.
+
+  var _clickLinkTimes = 0;
+  function clickLinkIfReady() {
+    _clickLinkTimes++;
+    if (_clickLinkTimes == 2) {
+      BrowserTestUtils.synthesizeMouseAtCenter(
+        "#firefox-link",
+        {},
+        gBrowser.selectedBrowser
+      );
+    }
+  }
+
+  function onPageLoad() {
+    clickLinkIfReady();
+  }
+
+  // Make sure neither of the test pages haven't been loaded before.
+  var info = getNavHistoryEntry(makeURI(pageurl));
+  ok(!info, "The test page must not have been visited already.");
+  info = getNavHistoryEntry(makeURI(fragmenturl));
+  ok(!info, "The fragment test page must not have been visited already.");
+
+  let promiseIcon1 = PlacesTestUtils.waitForNotification(
+    "favicon-changed",
+    events =>
+      events.some(e => {
+        if (e.url == pageurl) {
+          ok(
+            e.faviconUrl,
+            "Favicon value is not null for page without fragment."
+          );
+          originalFavicon = e.faviconUrl;
+
+          // Now that the favicon has loaded, click on fragment link.
+          // This should trigger the |case fragmenturl| below.
+          clickLinkIfReady();
+          return true;
+        }
+        return false;
+      })
+  );
+  let promiseIcon2 = PlacesTestUtils.waitForNotification(
+    "favicon-changed",
+    events =>
+      events.some(e => {
+        if (e.url == fragmenturl) {
+          // If the fragment URL's favicon isn't set, this branch won't
+          // be called and the test will time out.
+          is(
+            e.faviconUrl,
+            originalFavicon,
+            "New favicon should be same as original favicon."
+          );
+          ok(
+            e.faviconUrl,
+            "Favicon value is not null for page without fragment."
+          );
+          originalFavicon = e.faviconUrl;
+
+          // Now that the favicon has loaded, click on fragment link.
+          // This should trigger the |case fragmenturl| below.
+          clickLinkIfReady();
+          return true;
+        }
+        return false;
+      })
+  );
+
+  // Now open the test page in a new tab.
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser);
+  BrowserTestUtils.waitForContentEvent(
+    gBrowser.selectedBrowser,
+    "DOMContentLoaded",
+    true
+  ).then(onPageLoad);
+  BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, pageurl);
+
+  await promiseIcon1;
+  await promiseIcon2;
+
+  // Let's explicitly check that we can get the favicon
+  // from nsINavHistoryService now.
+  info = getNavHistoryEntry(makeURI(fragmenturl));
+  ok(info, "There must be a history entry for the fragment.");
+  ok(info.icon, "The history entry must have an associated favicon.");
+  gBrowser.removeCurrentTab();
+});
diff --git a/docshell/test/browser/browser_bug422543.js b/docshell/test/browser/browser_bug422543.js
new file mode 100644
index 0000000000..d2b6370d03
--- /dev/null
+++ b/docshell/test/browser/browser_bug422543.js
@@ -0,0 +1,253 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const ACTOR = "Bug422543";
+
+let getActor = browser => {
+  return browser.browsingContext.currentWindowGlobal.getActor(ACTOR);
+};
+
+add_task(async function runTests() {
+  if (!SpecialPowers.Services.appinfo.sessionHistoryInParent) {
+    await setupAsync();
+    let browser = gBrowser.selectedBrowser;
+    // Now that we're set up, initialize our frame script.
+    await checkListenersAsync("initial", "listeners initialized");
+
+    // Check if all history listeners are always notified.
+    info("# part 1");
+    await whenPageShown(browser, () =>
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+      BrowserTestUtils.startLoadingURIString(browser, "http://www.example.com/")
+    );
+    await checkListenersAsync("newentry", "shistory has a new entry");
+    ok(browser.canGoBack, "we can go back");
+
+    await whenPageShown(browser, () => browser.goBack());
+    await checkListenersAsync("gotoindex", "back to the first shentry");
+    ok(browser.canGoForward, "we can go forward");
+
+    await whenPageShown(browser, () => browser.goForward());
+    await checkListenersAsync("gotoindex", "forward to the second shentry");
+
+    await whenPageShown(browser, () => browser.reload());
+    await checkListenersAsync("reload", "current shentry reloaded");
+
+    await whenPageShown(browser, () => browser.gotoIndex(0));
+    await checkListenersAsync("gotoindex", "back to the first index");
+
+    // Check nsISHistory.notifyOnHistoryReload
+    info("# part 2");
+    ok(await notifyReloadAsync(), "reloading has not been canceled");
+    await checkListenersAsync("reload", "saw the reload notification");
+
+    // Let the first listener cancel the reload action.
+    info("# part 3");
+    await resetListenersAsync();
+    await setListenerRetvalAsync(0, false);
+    ok(!(await notifyReloadAsync()), "reloading has been canceled");
+    await checkListenersAsync("reload", "saw the reload notification");
+
+    // Let both listeners cancel the reload action.
+    info("# part 4");
+    await resetListenersAsync();
+    await setListenerRetvalAsync(1, false);
+    ok(!(await notifyReloadAsync()), "reloading has been canceled");
+    await checkListenersAsync("reload", "saw the reload notification");
+
+    // Let the second listener cancel the reload action.
+    info("# part 5");
+    await resetListenersAsync();
+    await setListenerRetvalAsync(0, true);
+    ok(!(await notifyReloadAsync()), "reloading has been canceled");
+    await checkListenersAsync("reload", "saw the reload notification");
+
+    function sendQuery(message, arg = {}) {
+      return getActor(gBrowser.selectedBrowser).sendQuery(message, arg);
+    }
+
+    function checkListenersAsync(aLast, aMessage) {
+      return sendQuery("getListenerStatus").then(listenerStatuses => {
+        is(listenerStatuses[0], aLast, aMessage);
+        is(listenerStatuses[1], aLast, aMessage);
+      });
+    }
+
+    function resetListenersAsync() {
+      return sendQuery("resetListeners");
+    }
+
+    function notifyReloadAsync() {
+      return sendQuery("notifyReload").then(({ rval }) => {
+        return rval;
+      });
+    }
+
+    function setListenerRetvalAsync(num, val) {
+      return sendQuery("setRetval", { num, val });
+    }
+
+    async function setupAsync() {
+      let tab = await BrowserTestUtils.openNewForegroundTab(
+        gBrowser,
+        "http://mochi.test:8888"
+      );
+
+      let base = getRootDirectory(gTestPath).slice(0, -1);
+      ChromeUtils.registerWindowActor(ACTOR, {
+        child: {
+          esModuleURI: `${base}/Bug422543Child.sys.mjs`,
+        },
+      });
+
+      registerCleanupFunction(async () => {
+        await sendQuery("cleanup");
+        gBrowser.removeTab(tab);
+
+        ChromeUtils.unregisterWindowActor(ACTOR);
+      });
+
+      await sendQuery("init");
+    }
+    return;
+  }
+
+  await setup();
+  let browser = gBrowser.selectedBrowser;
+  // Now that we're set up, initialize our frame script.
+  checkListeners("initial", "listeners initialized");
+
+  // Check if all history listeners are always notified.
+  info("# part 1");
+  await whenPageShown(browser, () =>
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    BrowserTestUtils.startLoadingURIString(browser, "http://www.example.com/")
+  );
+  checkListeners("newentry", "shistory has a new entry");
+  ok(browser.canGoBack, "we can go back");
+
+  await whenPageShown(browser, () => browser.goBack());
+  checkListeners("gotoindex", "back to the first shentry");
+  ok(browser.canGoForward, "we can go forward");
+
+  await whenPageShown(browser, () => browser.goForward());
+  checkListeners("gotoindex", "forward to the second shentry");
+
+  await whenPageShown(browser, () => browser.reload());
+  checkListeners("reload", "current shentry reloaded");
+
+  await whenPageShown(browser, () => browser.gotoIndex(0));
+  checkListeners("gotoindex", "back to the first index");
+
+  // Check nsISHistory.notifyOnHistoryReload
+  info("# part 2");
+  ok(notifyReload(browser), "reloading has not been canceled");
+  checkListeners("reload", "saw the reload notification");
+
+  // Let the first listener cancel the reload action.
+  info("# part 3");
+  resetListeners();
+  setListenerRetval(0, false);
+  ok(!notifyReload(browser), "reloading has been canceled");
+  checkListeners("reload", "saw the reload notification");
+
+  // Let both listeners cancel the reload action.
+  info("# part 4");
+  resetListeners();
+  setListenerRetval(1, false);
+  ok(!notifyReload(browser), "reloading has been canceled");
+  checkListeners("reload", "saw the reload notification");
+
+  // Let the second listener cancel the reload action.
+  info("# part 5");
+  resetListeners();
+  setListenerRetval(0, true);
+  ok(!notifyReload(browser), "reloading has been canceled");
+  checkListeners("reload", "saw the reload notification");
+});
+
+class SHistoryListener {
+  constructor() {
+    this.retval = true;
+    this.last = "initial";
+  }
+
+  OnHistoryNewEntry(aNewURI) {
+    this.last = "newentry";
+  }
+
+  OnHistoryGotoIndex() {
+    this.last = "gotoindex";
+  }
+
+  OnHistoryPurge() {
+    this.last = "purge";
+  }
+
+  OnHistoryReload() {
+    this.last = "reload";
+    return this.retval;
+  }
+
+  OnHistoryReplaceEntry() {}
+}
+SHistoryListener.prototype.QueryInterface = ChromeUtils.generateQI([
+  "nsISHistoryListener",
+  "nsISupportsWeakReference",
+]);
+
+let listeners = [new SHistoryListener(), new SHistoryListener()];
+
+function checkListeners(aLast, aMessage) {
+  is(listeners[0].last, aLast, aMessage);
+  is(listeners[1].last, aLast, aMessage);
+}
+
+function resetListeners() {
+  for (let listener of listeners) {
+    listener.last = "initial";
+  }
+}
+
+function notifyReload(browser) {
+  return browser.browsingContext.sessionHistory.notifyOnHistoryReload();
+}
+
+function setListenerRetval(num, val) {
+  listeners[num].retval = val;
+}
+
+async function setup() {
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "http://mochi.test:8888"
+  );
+
+  let browser = tab.linkedBrowser;
+  registerCleanupFunction(async function () {
+    for (let listener of listeners) {
+      browser.browsingContext.sessionHistory.removeSHistoryListener(listener);
+    }
+    gBrowser.removeTab(tab);
+  });
+  for (let listener of listeners) {
+    browser.browsingContext.sessionHistory.addSHistoryListener(listener);
+  }
+}
+
+function whenPageShown(aBrowser, aNavigation) {
+  let promise = new Promise(resolve => {
+    let unregister = BrowserTestUtils.addContentEventListener(
+      aBrowser,
+      "pageshow",
+      () => {
+        unregister();
+        resolve();
+      },
+      { capture: true }
+    );
+  });
+
+  aNavigation();
+  return promise;
+}
diff --git a/docshell/test/browser/browser_bug441169.js b/docshell/test/browser/browser_bug441169.js
new file mode 100644
index 0000000000..09e83b040c
--- /dev/null
+++ b/docshell/test/browser/browser_bug441169.js
@@ -0,0 +1,44 @@
+/* Make sure that netError won't allow HTML injection through badcert parameters.  See bug 441169. */
+var newBrowser;
+
+function task() {
+  let resolve;
+  let promise = new Promise(r => {
+    resolve = r;
+  });
+
+  addEventListener("DOMContentLoaded", checkPage, false);
+
+  function checkPage(event) {
+    if (event.target != content.document) {
+      return;
+    }
+    removeEventListener("DOMContentLoaded", checkPage, false);
+
+    is(
+      content.document.getElementById("test_span"),
+      null,
+      "Error message should not be parsed as HTML, and hence shouldn't include the 'test_span' element."
+    );
+    resolve();
+  }
+
+  var chromeURL =
+    "about:neterror?e=nssBadCert&u=https%3A//test.kuix.de/&c=UTF-8&d=This%20sentence%20should%20not%20be%20parsed%20to%20include%20a%20%3Cspan%20id=%22test_span%22%3Enamed%3C/span%3E%20span%20tag.%0A%0AThe%20certificate%20is%20only%20valid%20for%20%3Ca%20id=%22cert_domain_link%22%20title=%22kuix.de%22%3Ekuix.de%3C/a%3E%0A%0A(Error%20code%3A%20ssl_error_bad_cert_domain)";
+  content.location = chromeURL;
+
+  return promise;
+}
+
+function test() {
+  waitForExplicitFinish();
+
+  var newTab = BrowserTestUtils.addTab(gBrowser);
+  gBrowser.selectedTab = newTab;
+  newBrowser = gBrowser.getBrowserForTab(newTab);
+
+  ContentTask.spawn(newBrowser, null, task).then(() => {
+    gBrowser.removeCurrentTab();
+    finish();
+  });
+}
diff --git a/docshell/test/browser/browser_bug503832.js b/docshell/test/browser/browser_bug503832.js
new file mode 100644
index 0000000000..8699eb01fc
--- /dev/null
+++ b/docshell/test/browser/browser_bug503832.js
@@ -0,0 +1,76 @@
+/* Test for Bug 503832
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=503832
+ */
+
+add_task(async function () {
+  var pagetitle = "Page Title for Bug 503832";
+  var pageurl =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_bug503832.html";
+  var fragmenturl =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_bug503832.html#firefox";
+
+  var historyService = Cc[
+    "@mozilla.org/browser/nav-history-service;1"
+  ].getService(Ci.nsINavHistoryService);
+
+  let fragmentPromise = new Promise(resolve => {
+    const listener = events => {
+      const { url, title } = events[0];
+
+      switch (url) {
+        case pageurl:
+          is(title, pagetitle, "Correct page title for " + url);
+          return;
+        case fragmenturl:
+          is(title, pagetitle, "Correct page title for " + url);
+          // If titles for fragment URLs aren't set, this code
+          // branch won't be called and the test will timeout,
+          // resulting in a failure
+          PlacesObservers.removeListener(["page-title-changed"], listener);
+          resolve();
+      }
+    };
+
+    PlacesObservers.addListener(["page-title-changed"], listener);
+  });
+
+  /* Queries nsINavHistoryService and returns a single history entry
+   * for a given URI */
+  function getNavHistoryEntry(aURI) {
+    var options = historyService.getNewQueryOptions();
+    options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_HISTORY;
+    options.maxResults = 1;
+
+    var query = historyService.getNewQuery();
+    query.uri = aURI;
+
+    var result = historyService.executeQuery(query, options);
+    result.root.containerOpen = true;
+
+    if (!result.root.childCount) {
+      return null;
+    }
+    var node = result.root.getChild(0);
+    result.root.containerOpen = false;
+    return node;
+  }
+
+  // Make sure neither of the test pages haven't been loaded before.
+  var info = getNavHistoryEntry(makeURI(pageurl));
+  ok(!info, "The test page must not have been visited already.");
+  info = getNavHistoryEntry(makeURI(fragmenturl));
+  ok(!info, "The fragment test page must not have been visited already.");
+
+  // Now open the test page in a new tab
+  await BrowserTestUtils.openNewForegroundTab(gBrowser, pageurl);
+
+  // Now that the page is loaded, click on fragment link
+  await BrowserTestUtils.synthesizeMouseAtCenter(
+    "#firefox-link",
+    {},
+    gBrowser.selectedBrowser
+  );
+  await fragmentPromise;
+
+  gBrowser.removeCurrentTab();
+});
diff --git a/docshell/test/browser/browser_bug554155.js b/docshell/test/browser/browser_bug554155.js
new file mode 100644
index 0000000000..223f6241de
--- /dev/null
+++ b/docshell/test/browser/browser_bug554155.js
@@ -0,0 +1,33 @@
+add_task(async function test() {
+  await BrowserTestUtils.withNewTab(
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    { gBrowser, url: "http://example.com" },
+    async function (browser) {
+      let numLocationChanges = 0;
+
+      let listener = {
+        onLocationChange(browser, webProgress, request, uri, flags) {
+          info("location change: " + (uri && uri.spec));
+          numLocationChanges++;
+        },
+      };
+
+      gBrowser.addTabsProgressListener(listener);
+
+      await SpecialPowers.spawn(browser, [], function () {
+        // pushState to a new URL (http://example.com/foo").  This should trigger
+        // exactly one LocationChange event.
+        content.history.pushState(null, null, "foo");
+      });
+
+      await Promise.resolve();
+
+      gBrowser.removeTabsProgressListener(listener);
+      is(
+        numLocationChanges,
+        1,
+        "pushState should cause exactly one LocationChange event."
+      );
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug655270.js b/docshell/test/browser/browser_bug655270.js
new file mode 100644
index 0000000000..3120abb269
--- /dev/null
+++ b/docshell/test/browser/browser_bug655270.js
@@ -0,0 +1,62 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test for Bug 655273
+ *
+ * Call pushState and then make sure that the favicon service associates our
+ * old favicon with the new URI.
+ */
+
+const { PlacesTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PlacesTestUtils.sys.mjs"
+);
+
+add_task(async function test() {
+  const testDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  const origURL = testDir + "file_bug655270.html";
+  const newURL = origURL + "?new_page";
+
+  const faviconURL = testDir + "favicon_bug655270.ico";
+
+  let icon1;
+  let promiseIcon1 = PlacesTestUtils.waitForNotification(
+    "favicon-changed",
+    events =>
+      events.some(e => {
+        if (e.url == origURL) {
+          icon1 = e.faviconUrl;
+          return true;
+        }
+        return false;
+      })
+  );
+  let icon2;
+  let promiseIcon2 = PlacesTestUtils.waitForNotification(
+    "favicon-changed",
+    events =>
+      events.some(e => {
+        if (e.url == newURL) {
+          icon2 = e.faviconUrl;
+          return true;
+        }
+        return false;
+      })
+  );
+
+  // The page at origURL has a <link rel='icon'>, so we should get a call into
+  // our observer below when it loads.  Once we verify that we have the right
+  // favicon URI, we call pushState, which should trigger another favicon change
+  // event, this time for the URI after pushState.
+  let tab = BrowserTestUtils.addTab(gBrowser, origURL);
+  await promiseIcon1;
+  is(icon1, faviconURL, "FaviconURL for original URI");
+  // Ignore the promise returned here and wait for the next
+  // onPageChanged notification.
+  SpecialPowers.spawn(tab.linkedBrowser, [], function () {
+    content.history.pushState("", "", "?new_page");
+  });
+  await promiseIcon2;
+  is(icon2, faviconURL, "FaviconURL for new URI");
+  gBrowser.removeTab(tab);
+});
diff --git a/docshell/test/browser/browser_bug655273.js b/docshell/test/browser/browser_bug655273.js
new file mode 100644
index 0000000000..e564eb2f6c
--- /dev/null
+++ b/docshell/test/browser/browser_bug655273.js
@@ -0,0 +1,56 @@
+/* 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/. */
+
+/**
+ * Test for Bug 655273.  Make sure that after changing the URI via
+ * history.pushState, the resulting SHEntry has the same title as our old
+ * SHEntry.
+ */
+
+add_task(async function test() {
+  waitForExplicitFinish();
+
+  await BrowserTestUtils.withNewTab(
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    { gBrowser, url: "http://example.com" },
+    async function (browser) {
+      if (!SpecialPowers.Services.appinfo.sessionHistoryInParent) {
+        await SpecialPowers.spawn(browser, [], async function () {
+          let cw = content;
+          let oldTitle = cw.document.title;
+          ok(oldTitle, "Content window should initially have a title.");
+          cw.history.pushState("", "", "new_page");
+
+          let shistory = cw.docShell.QueryInterface(
+            Ci.nsIWebNavigation
+          ).sessionHistory;
+
+          is(
+            shistory.legacySHistory.getEntryAtIndex(shistory.index).title,
+            oldTitle,
+            "SHEntry title after pushstate."
+          );
+        });
+
+        return;
+      }
+
+      let bc = browser.browsingContext;
+      let oldTitle = browser.browsingContext.currentWindowGlobal.documentTitle;
+      ok(oldTitle, "Content window should initially have a title.");
+      SpecialPowers.spawn(browser, [], async function () {
+        content.history.pushState("", "", "new_page");
+      });
+
+      let shistory = bc.sessionHistory;
+      await SHListener.waitForHistory(shistory, SHListener.NewEntry);
+
+      is(
+        shistory.getEntryAtIndex(shistory.index).title,
+        oldTitle,
+        "SHEntry title after pushstate."
+      );
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug670318.js b/docshell/test/browser/browser_bug670318.js
new file mode 100644
index 0000000000..6fad3d39e6
--- /dev/null
+++ b/docshell/test/browser/browser_bug670318.js
@@ -0,0 +1,146 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test for Bug 670318
+ *
+ * When LoadEntry() is called on a browser that has multiple duplicate history
+ * entries, history.index can end up out of range (>= history.count).
+ */
+
+const URL =
+  "http://mochi.test:8888/browser/docshell/test/browser/file_bug670318.html";
+
+add_task(async function test() {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: "about:blank" },
+    async function (browser) {
+      if (!SpecialPowers.Services.appinfo.sessionHistoryInParent) {
+        await ContentTask.spawn(browser, URL, async function (URL) {
+          let history = docShell.QueryInterface(
+            Ci.nsIWebNavigation
+          ).sessionHistory;
+          let count = 0;
+
+          let testDone = {};
+          testDone.promise = new Promise(resolve => {
+            testDone.resolve = resolve;
+          });
+
+          // Since listener implements nsISupportsWeakReference, we are
+          // responsible for keeping it alive so that the GC doesn't clear
+          // it before the test completes. We do this by anchoring the listener
+          // to the message manager, and clearing it just before the test
+          // completes.
+          this._testListener = {
+            owner: this,
+            OnHistoryNewEntry(aNewURI) {
+              info("OnHistoryNewEntry " + aNewURI.spec + ", " + count);
+              if (aNewURI.spec == URL && 5 == ++count) {
+                addEventListener(
+                  "load",
+                  function onLoad() {
+                    Assert.ok(
+                      history.index < history.count,
+                      "history.index is valid"
+                    );
+                    testDone.resolve();
+                  },
+                  { capture: true, once: true }
+                );
+
+                history.legacySHistory.removeSHistoryListener(
+                  this.owner._testListener
+                );
+                delete this.owner._testListener;
+                this.owner = null;
+                content.setTimeout(() => {
+                  content.location.reload();
+                }, 0);
+              }
+            },
+
+            OnHistoryReload: () => true,
+            OnHistoryGotoIndex: () => {},
+            OnHistoryPurge: () => {},
+            OnHistoryReplaceEntry: () => {
+              // The initial load of about:blank causes a transient entry to be
+              // created, so our first navigation to a real page is a replace
+              // instead of a new entry.
+              ++count;
+            },
+
+            QueryInterface: ChromeUtils.generateQI([
+              "nsISHistoryListener",
+              "nsISupportsWeakReference",
+            ]),
+          };
+
+          history.legacySHistory.addSHistoryListener(this._testListener);
+          content.location = URL;
+
+          await testDone.promise;
+        });
+
+        return;
+      }
+
+      let history = browser.browsingContext.sessionHistory;
+      let count = 0;
+
+      let testDone = {};
+      testDone.promise = new Promise(resolve => {
+        testDone.resolve = resolve;
+      });
+
+      let listener = {
+        async OnHistoryNewEntry(aNewURI) {
+          if (aNewURI.spec == URL && 5 == ++count) {
+            history.removeSHistoryListener(listener);
+            await ContentTask.spawn(browser, null, () => {
+              return new Promise(resolve => {
+                addEventListener(
+                  "load",
+                  evt => {
+                    let history = docShell.QueryInterface(
+                      Ci.nsIWebNavigation
+                    ).sessionHistory;
+                    Assert.ok(
+                      history.index < history.count,
+                      "history.index is valid"
+                    );
+                    resolve();
+                  },
+                  { capture: true, once: true }
+                );
+
+                content.location.reload();
+              });
+            });
+            testDone.resolve();
+          }
+        },
+
+        OnHistoryReload: () => true,
+        OnHistoryGotoIndex: () => {},
+        OnHistoryPurge: () => {},
+        OnHistoryReplaceEntry: () => {
+          // The initial load of about:blank causes a transient entry to be
+          // created, so our first navigation to a real page is a replace
+          // instead of a new entry.
+          ++count;
+        },
+
+        QueryInterface: ChromeUtils.generateQI([
+          "nsISHistoryListener",
+          "nsISupportsWeakReference",
+        ]),
+      };
+
+      history.addSHistoryListener(listener);
+      BrowserTestUtils.startLoadingURIString(browser, URL);
+
+      await testDone.promise;
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_bug673087-1.js b/docshell/test/browser/browser_bug673087-1.js
new file mode 100644
index 0000000000..427b246d76
--- /dev/null
+++ b/docshell/test/browser/browser_bug673087-1.js
@@ -0,0 +1,46 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug673087-1.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u00A4"),
+    151,
+    "Parent doc should be windows-1252 initially"
+  );
+
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u00A4"),
+    95,
+    "Child doc should be windows-1252 initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\u3042"),
+    151,
+    "Parent doc should decode as EUC-JP subsequently"
+  );
+  is(
+    content.frames[0].document.documentElement.textContent.indexOf("\u3042"),
+    95,
+    "Child doc should decode as EUC-JP subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "EUC-JP",
+    "Parent doc should report EUC-JP subsequently"
+  );
+  is(
+    content.frames[0].document.characterSet,
+    "EUC-JP",
+    "Child doc should report EUC-JP subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug673087-2.js b/docshell/test/browser/browser_bug673087-2.js
new file mode 100644
index 0000000000..13a7a2a82c
--- /dev/null
+++ b/docshell/test/browser/browser_bug673087-2.js
@@ -0,0 +1,36 @@
+function test() {
+  var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+  runCharsetTest(
+    rootDir + "file_bug673087-2.html",
+    afterOpen,
+    afterChangeCharset
+  );
+}
+
+function afterOpen() {
+  is(
+    content.document.documentElement.textContent.indexOf("\uFFFD"),
+    0,
+    "Doc should decode as replacement initially"
+  );
+
+  is(
+    content.document.characterSet,
+    "replacement",
+    "Doc should report replacement initially"
+  );
+}
+
+function afterChangeCharset() {
+  is(
+    content.document.documentElement.textContent.indexOf("\uFFFD"),
+    0,
+    "Doc should decode as replacement subsequently"
+  );
+
+  is(
+    content.document.characterSet,
+    "replacement",
+    "Doc should report replacement subsequently"
+  );
+}
diff --git a/docshell/test/browser/browser_bug673467.js b/docshell/test/browser/browser_bug673467.js
new file mode 100644
index 0000000000..507410254c
--- /dev/null
+++ b/docshell/test/browser/browser_bug673467.js
@@ -0,0 +1,62 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test for bug 673467.  In a new tab, load a page which inserts a new iframe
+// before the load and then sets its location during the load.  This should
+// create just one SHEntry.
+
+var doc =
+  "data:text/html,<html><body onload='load()'>" +
+  "<script>" +
+  "  var iframe = document.createElement('iframe');" +
+  "  iframe.id = 'iframe';" +
+  "  document.documentElement.appendChild(iframe);" +
+  "  function load() {" +
+  "    iframe.src = 'data:text/html,Hello!';" +
+  "  }" +
+  "</script>" +
+  "</body></html>";
+
+function test() {
+  waitForExplicitFinish();
+
+  let taskFinished;
+
+  let tab = BrowserTestUtils.addTab(gBrowser, doc, {}, tab => {
+    taskFinished = ContentTask.spawn(tab.linkedBrowser, null, () => {
+      return new Promise(resolve => {
+        addEventListener(
+          "load",
+          function () {
+            // The main page has loaded.  Now wait for the iframe to load.
+            let iframe = content.document.getElementById("iframe");
+            iframe.addEventListener(
+              "load",
+              function listener(aEvent) {
+                // Wait for the iframe to load the new document, not about:blank.
+                if (!iframe.src) {
+                  return;
+                }
+
+                iframe.removeEventListener("load", listener, true);
+                let shistory = content.docShell.QueryInterface(
+                  Ci.nsIWebNavigation
+                ).sessionHistory;
+
+                Assert.equal(shistory.count, 1, "shistory count should be 1.");
+                resolve();
+              },
+              true
+            );
+          },
+          true
+        );
+      });
+    });
+  });
+
+  taskFinished.then(() => {
+    gBrowser.removeTab(tab);
+    finish();
+  });
+}
diff --git a/docshell/test/browser/browser_bug852909.js b/docshell/test/browser/browser_bug852909.js
new file mode 100644
index 0000000000..108baa0626
--- /dev/null
+++ b/docshell/test/browser/browser_bug852909.js
@@ -0,0 +1,35 @@
+var rootDir = "http://mochi.test:8888/browser/docshell/test/browser/";
+
+function test() {
+  waitForExplicitFinish();
+
+  gBrowser.selectedTab = BrowserTestUtils.addTab(
+    gBrowser,
+    rootDir + "file_bug852909.png"
+  );
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(image);
+}
+
+function image(event) {
+  ok(
+    !gBrowser.selectedTab.mayEnableCharacterEncodingMenu,
+    "Docshell should say the menu should be disabled for images."
+  );
+
+  gBrowser.removeCurrentTab();
+  gBrowser.selectedTab = BrowserTestUtils.addTab(
+    gBrowser,
+    rootDir + "file_bug852909.pdf"
+  );
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(pdf);
+}
+
+function pdf(event) {
+  ok(
+    !gBrowser.selectedTab.mayEnableCharacterEncodingMenu,
+    "Docshell should say the menu should be disabled for PDF.js."
+  );
+
+  gBrowser.removeCurrentTab();
+  finish();
+}
diff --git a/docshell/test/browser/browser_bug92473.js b/docshell/test/browser/browser_bug92473.js
new file mode 100644
index 0000000000..7e386f5ee9
--- /dev/null
+++ b/docshell/test/browser/browser_bug92473.js
@@ -0,0 +1,70 @@
+/* The test text as octets for reference
+ * %83%86%83%6a%83%52%81%5b%83%68%82%cd%81%41%82%b7%82%d7%82%c4%82%cc%95%b6%8e%9a%82%c9%8c%c5%97%4c%82%cc%94%d4%8d%86%82%f0%95%74%97%5e%82%b5%82%dc%82%b7
+ */
+
+function testContent(text) {
+  return SpecialPowers.spawn(gBrowser.selectedBrowser, [text], text => {
+    Assert.equal(
+      content.document.getElementById("testpar").innerHTML,
+      text,
+      "<p> contains expected text"
+    );
+    Assert.equal(
+      content.document.getElementById("testtextarea").innerHTML,
+      text,
+      "<textarea> contains expected text"
+    );
+    Assert.equal(
+      content.document.getElementById("testinput").value,
+      text,
+      "<input> contains expected text"
+    );
+  });
+}
+
+function afterOpen() {
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(
+    afterChangeCharset
+  );
+
+  /* The test text decoded incorrectly as Windows-1251. This is the "right" wrong
+   text; anything else is unexpected. */
+  const wrongText =
+    "\u0453\u2020\u0453\u006A\u0453\u0052\u0403\u005B\u0453\u0068\u201A\u041D\u0403\u0041\u201A\u00B7\u201A\u0427\u201A\u0414\u201A\u041C\u2022\u00B6\u040B\u0459\u201A\u0419\u040A\u0415\u2014\u004C\u201A\u041C\u201D\u0424\u040C\u2020\u201A\u0440\u2022\u0074\u2014\u005E\u201A\u00B5\u201A\u042C\u201A\u00B7";
+
+  /* Test that the content on load is the expected wrong decoding */
+  testContent(wrongText).then(() => {
+    BrowserForceEncodingDetection();
+  });
+}
+
+function afterChangeCharset() {
+  /* The test text decoded correctly as Shift_JIS */
+  const rightText =
+    "\u30E6\u30CB\u30B3\u30FC\u30C9\u306F\u3001\u3059\u3079\u3066\u306E\u6587\u5B57\u306B\u56FA\u6709\u306E\u756A\u53F7\u3092\u4ED8\u4E0E\u3057\u307E\u3059";
+
+  /* test that the content is decoded correctly */
+  testContent(rightText).then(() => {
+    gBrowser.removeCurrentTab();
+    finish();
+  });
+}
+
+function test() {
+  waitForExplicitFinish();
+
+  // Get the local directory. This needs to be a file: URI because chrome: URIs
+  // are always UTF-8 (bug 617339) and we are testing decoding from other
+  // charsets.
+  var jar = getJar(getRootDirectory(gTestPath));
+  var dir = jar
+    ? extractJarToTmp(jar)
+    : getChromeDir(getResolvedURI(gTestPath));
+  var rootDir = Services.io.newFileURI(dir).spec;
+
+  gBrowser.selectedTab = BrowserTestUtils.addTab(
+    gBrowser,
+    rootDir + "test-form_sjis.html"
+  );
+  BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(afterOpen);
+}
diff --git a/docshell/test/browser/browser_click_link_within_view_source.js b/docshell/test/browser/browser_click_link_within_view_source.js
new file mode 100644
index 0000000000..73542f977a
--- /dev/null
+++ b/docshell/test/browser/browser_click_link_within_view_source.js
@@ -0,0 +1,78 @@
+"use strict";
+
+/**
+ * Test for Bug 1359204
+ *
+ * Loading a local file, then view-source on that file. Make sure that
+ * clicking a link within that view-source page is not blocked by security checks.
+ */
+
+add_task(async function test_click_link_within_view_source() {
+  let TEST_FILE = "file_click_link_within_view_source.html";
+  let TEST_FILE_URI = getChromeDir(getResolvedURI(gTestPath));
+  TEST_FILE_URI.append(TEST_FILE);
+  TEST_FILE_URI = Services.io.newFileURI(TEST_FILE_URI).spec;
+
+  let DUMMY_FILE = "dummy_page.html";
+  let DUMMY_FILE_URI = getChromeDir(getResolvedURI(gTestPath));
+  DUMMY_FILE_URI.append(DUMMY_FILE);
+  DUMMY_FILE_URI = Services.io.newFileURI(DUMMY_FILE_URI).spec;
+
+  await BrowserTestUtils.withNewTab(TEST_FILE_URI, async function (aBrowser) {
+    let tabSpec = gBrowser.selectedBrowser.currentURI.spec;
+    info("loading: " + tabSpec);
+    ok(
+      tabSpec.startsWith("file://") && tabSpec.endsWith(TEST_FILE),
+      "sanity check to make sure html loaded"
+    );
+
+    info("click view-source of html");
+    let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser);
+    document.getElementById("View:PageSource").doCommand();
+
+    let tab = await tabPromise;
+    tabSpec = gBrowser.selectedBrowser.currentURI.spec;
+    info("loading: " + tabSpec);
+    ok(
+      tabSpec.startsWith("view-source:file://") && tabSpec.endsWith(TEST_FILE),
+      "loading view-source of html succeeded"
+    );
+
+    info("click testlink within view-source page");
+    let loadPromise = BrowserTestUtils.browserLoaded(
+      tab.linkedBrowser,
+      false,
+      url => url.endsWith("dummy_page.html")
+    );
+    await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async function () {
+      if (content.document.readyState != "complete") {
+        await ContentTaskUtils.waitForEvent(
+          content.document,
+          "readystatechange",
+          false,
+          () => content.document.readyState == "complete"
+        );
+      }
+      // document.getElementById() does not work on a view-source page, hence we use document.links
+      let linksOnPage = content.document.links;
+      is(
+        linksOnPage.length,
+        1,
+        "sanity check: make sure only one link is present on page"
+      );
+      let myLink = content.document.links[0];
+      myLink.click();
+    });
+
+    await loadPromise;
+
+    tabSpec = gBrowser.selectedBrowser.currentURI.spec;
+    info("loading: " + tabSpec);
+    ok(
+      tabSpec.startsWith("view-source:file://") && tabSpec.endsWith(DUMMY_FILE),
+      "loading view-source of html succeeded"
+    );
+
+    BrowserTestUtils.removeTab(tab);
+  });
+});
diff --git a/docshell/test/browser/browser_cross_process_csp_inheritance.js b/docshell/test/browser/browser_cross_process_csp_inheritance.js
new file mode 100644
index 0000000000..76be61d0f9
--- /dev/null
+++ b/docshell/test/browser/browser_cross_process_csp_inheritance.js
@@ -0,0 +1,125 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com"
+);
+const TEST_URI = TEST_PATH + "file_cross_process_csp_inheritance.html";
+const DATA_URI =
+  "data:text/html,<html>test-same-diff-process-csp-inhertiance</html>";
+
+const FISSION_ENABLED = SpecialPowers.useRemoteSubframes;
+
+function getCurrentPID(aBrowser) {
+  return SpecialPowers.spawn(aBrowser, [], () => {
+    return Services.appinfo.processID;
+  });
+}
+
+function getCurrentURI(aBrowser) {
+  return SpecialPowers.spawn(aBrowser, [], () => {
+    let channel = content.docShell.currentDocumentChannel;
+    return channel.URI.asciiSpec;
+  });
+}
+
+function verifyResult(
+  aTestName,
+  aBrowser,
+  aDataURI,
+  aPID,
+  aSamePID,
+  aFissionEnabled
+) {
+  return SpecialPowers.spawn(
+    aBrowser,
+    [{ aTestName, aDataURI, aPID, aSamePID, aFissionEnabled }],
+    async function ({ aTestName, aDataURI, aPID, aSamePID, aFissionEnabled }) {
+      // sanity, to make sure the correct URI was loaded
+      let channel = content.docShell.currentDocumentChannel;
+      is(
+        channel.URI.asciiSpec,
+        aDataURI,
+        aTestName + ": correct data uri loaded"
+      );
+
+      // check that the process ID is the same/different when opening the new tab
+      let pid = Services.appinfo.processID;
+      if (aSamePID) {
+        is(pid, aPID, aTestName + ": process ID needs to be identical");
+      } else if (aFissionEnabled) {
+        // TODO: Fission discards dom.noopener.newprocess.enabled and puts
+        // data: URIs in the same process. Unfortunately todo_isnot is not
+        // defined in that scope, hence we have to use a workaround.
+        todo(
+          false,
+          pid == aPID,
+          ": process ID needs to be different in fission"
+        );
+      } else {
+        isnot(pid, aPID, aTestName + ": process ID needs to be different");
+      }
+
+      // finally, evaluate that the CSP was set.
+      let cspOBJ = JSON.parse(content.document.cspJSON);
+      let policies = cspOBJ["csp-policies"];
+      is(policies.length, 1, "should be one policy");
+      let policy = policies[0];
+      is(
+        policy["script-src"],
+        "'none'",
+        aTestName + ": script-src directive matches"
+      );
+    }
+  );
+}
+
+async function simulateCspInheritanceForNewTab(aTestName, aSamePID) {
+  await BrowserTestUtils.withNewTab(TEST_URI, async function (browser) {
+    // do some sanity checks
+    let currentURI = await getCurrentURI(gBrowser.selectedBrowser);
+    is(currentURI, TEST_URI, aTestName + ": correct test uri loaded");
+
+    let pid = await getCurrentPID(gBrowser.selectedBrowser);
+    let loadPromise = BrowserTestUtils.waitForNewTab(gBrowser, DATA_URI, true);
+    // simulate click
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#testLink",
+      {},
+      gBrowser.selectedBrowser
+    );
+    let tab = await loadPromise;
+    gBrowser.selectTabAtIndex(2);
+    await verifyResult(
+      aTestName,
+      gBrowser.selectedBrowser,
+      DATA_URI,
+      pid,
+      aSamePID,
+      FISSION_ENABLED
+    );
+    await BrowserTestUtils.removeTab(tab);
+  });
+}
+
+add_task(async function test_csp_inheritance_diff_process() {
+  // forcing the new data: URI load to happen in a *new* process by flipping the pref
+  // to force <a rel="noopener" ...> to be loaded in a new process.
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.noopener.newprocess.enabled", true]],
+  });
+  await simulateCspInheritanceForNewTab("diff-process-inheritance", false);
+});
+
+add_task(async function test_csp_inheritance_same_process() {
+  // forcing the new data: URI load to happen in a *same* process by resetting the pref
+  // and loaded <a rel="noopener" ...> in the *same* process.
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.noopener.newprocess.enabled", false]],
+  });
+  await simulateCspInheritanceForNewTab("same-process-inheritance", true);
+});
diff --git a/docshell/test/browser/browser_csp_sandbox_no_script_js_uri.js b/docshell/test/browser/browser_csp_sandbox_no_script_js_uri.js
new file mode 100644
index 0000000000..d0b92084ec
--- /dev/null
+++ b/docshell/test/browser/browser_csp_sandbox_no_script_js_uri.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "https://example.com"
+);
+
+/**
+ * Test that javascript URIs in CSP-sandboxed contexts can't be used to bypass
+ * script restrictions.
+ */
+add_task(async function test_csp_sandbox_no_script_js_uri() {
+  await BrowserTestUtils.withNewTab(
+    TEST_PATH + "dummy_page.html",
+    async browser => {
+      info("Register observer and wait for javascript-uri-blocked message.");
+      let observerPromise = SpecialPowers.spawn(browser, [], () => {
+        return new Promise(resolve => {
+          SpecialPowers.addObserver(function obs(subject) {
+            ok(
+              subject == content,
+              "Should block script spawned via javascript uri"
+            );
+            SpecialPowers.removeObserver(
+              obs,
+              "javascript-uri-blocked-by-sandbox"
+            );
+            resolve();
+          }, "javascript-uri-blocked-by-sandbox");
+        });
+      });
+
+      info("Spawn csp-sandboxed iframe with javascript URI");
+      let frameBC = await SpecialPowers.spawn(
+        browser,
+        [TEST_PATH + "file_csp_sandbox_no_script_js_uri.html"],
+        async url => {
+          let frame = content.document.createElement("iframe");
+          let loadPromise = ContentTaskUtils.waitForEvent(frame, "load", true);
+          frame.src = url;
+          content.document.body.appendChild(frame);
+          await loadPromise;
+          return frame.browsingContext;
+        }
+      );
+
+      info("Click javascript URI link in iframe");
+      BrowserTestUtils.synthesizeMouseAtCenter("a", {}, frameBC);
+      await observerPromise;
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_csp_uir.js b/docshell/test/browser/browser_csp_uir.js
new file mode 100644
index 0000000000..2eb36d3d4d
--- /dev/null
+++ b/docshell/test/browser/browser_csp_uir.js
@@ -0,0 +1,89 @@
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com"
+);
+const TEST_URI = TEST_PATH + "file_csp_uir.html"; // important to be http: to test upgrade-insecure-requests
+const RESULT_URI =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  TEST_PATH.replace("http://", "https://") + "file_csp_uir_dummy.html";
+
+function verifyCSP(aTestName, aBrowser, aResultURI) {
+  return SpecialPowers.spawn(
+    aBrowser,
+    [{ aTestName, aResultURI }],
+    async function ({ aTestName, aResultURI }) {
+      let channel = content.docShell.currentDocumentChannel;
+      is(channel.URI.asciiSpec, aResultURI, "testing CSP for " + aTestName);
+    }
+  );
+}
+
+add_task(async function test_csp_inheritance_regular_click() {
+  await BrowserTestUtils.withNewTab(TEST_URI, async function (browser) {
+    let loadPromise = BrowserTestUtils.browserLoaded(
+      browser,
+      false,
+      RESULT_URI
+    );
+    // set the data href + simulate click
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#testlink",
+      {},
+      gBrowser.selectedBrowser
+    );
+    await loadPromise;
+    await verifyCSP("click()", gBrowser.selectedBrowser, RESULT_URI);
+  });
+});
+
+add_task(async function test_csp_inheritance_ctrl_click() {
+  await BrowserTestUtils.withNewTab(TEST_URI, async function (browser) {
+    let loadPromise = BrowserTestUtils.waitForNewTab(
+      gBrowser,
+      RESULT_URI,
+      true
+    );
+    // set the data href + simulate ctrl+click
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#testlink",
+      { ctrlKey: true, metaKey: true },
+      gBrowser.selectedBrowser
+    );
+    let tab = await loadPromise;
+    gBrowser.selectTabAtIndex(2);
+    await verifyCSP("ctrl-click()", gBrowser.selectedBrowser, RESULT_URI);
+    await BrowserTestUtils.removeTab(tab);
+  });
+});
+
+add_task(
+  async function test_csp_inheritance_right_click_open_link_in_new_tab() {
+    await BrowserTestUtils.withNewTab(TEST_URI, async function (browser) {
+      let loadPromise = BrowserTestUtils.waitForNewTab(gBrowser, RESULT_URI);
+      // set the data href + simulate right-click open link in tab
+      BrowserTestUtils.waitForEvent(document, "popupshown", false, event => {
+        // These are operations that must be executed synchronously with the event.
+        document.getElementById("context-openlinkintab").doCommand();
+        event.target.hidePopup();
+        return true;
+      });
+      BrowserTestUtils.synthesizeMouseAtCenter(
+        "#testlink",
+        { type: "contextmenu", button: 2 },
+        gBrowser.selectedBrowser
+      );
+
+      let tab = await loadPromise;
+      gBrowser.selectTabAtIndex(2);
+      await verifyCSP(
+        "right-click-open-in-new-tab()",
+        gBrowser.selectedBrowser,
+        RESULT_URI
+      );
+      await BrowserTestUtils.removeTab(tab);
+    });
+  }
+);
diff --git a/docshell/test/browser/browser_dataURI_unique_opaque_origin.js b/docshell/test/browser/browser_dataURI_unique_opaque_origin.js
new file mode 100644
index 0000000000..12cc3e06fb
--- /dev/null
+++ b/docshell/test/browser/browser_dataURI_unique_opaque_origin.js
@@ -0,0 +1,30 @@
+add_task(async function test_dataURI_unique_opaque_origin() {
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com");
+  let browser = tab.linkedBrowser;
+  await BrowserTestUtils.browserLoaded(browser);
+
+  let pagePrincipal = browser.contentPrincipal;
+  info("pagePrincial " + pagePrincipal.origin);
+
+  BrowserTestUtils.startLoadingURIString(browser, "data:text/html,hi");
+  await BrowserTestUtils.browserLoaded(browser);
+
+  await SpecialPowers.spawn(
+    browser,
+    [{ principal: pagePrincipal }],
+    async function (args) {
+      info("data URI principal: " + content.document.nodePrincipal.origin);
+      Assert.ok(
+        content.document.nodePrincipal.isNullPrincipal,
+        "data: URI should have NullPrincipal."
+      );
+      Assert.ok(
+        !content.document.nodePrincipal.equals(args.principal),
+        "data: URI should have unique opaque origin."
+      );
+    }
+  );
+
+  gBrowser.removeTab(tab);
+});
diff --git a/docshell/test/browser/browser_data_load_inherit_csp.js b/docshell/test/browser/browser_data_load_inherit_csp.js
new file mode 100644
index 0000000000..b2bc86e0ea
--- /dev/null
+++ b/docshell/test/browser/browser_data_load_inherit_csp.js
@@ -0,0 +1,110 @@
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com"
+);
+const HTML_URI = TEST_PATH + "file_data_load_inherit_csp.html";
+const DATA_URI = "data:text/html;html,<html><body>foo</body></html>";
+
+function setDataHrefOnLink(aBrowser, aDataURI) {
+  return SpecialPowers.spawn(aBrowser, [aDataURI], function (uri) {
+    let link = content.document.getElementById("testlink");
+    link.href = uri;
+  });
+}
+
+function verifyCSP(aTestName, aBrowser, aDataURI) {
+  return SpecialPowers.spawn(
+    aBrowser,
+    [{ aTestName, aDataURI }],
+    async function ({ aTestName, aDataURI }) {
+      let channel = content.docShell.currentDocumentChannel;
+      is(channel.URI.spec, aDataURI, "testing CSP for " + aTestName);
+      let cspJSON = content.document.cspJSON;
+      let cspOBJ = JSON.parse(cspJSON);
+      let policies = cspOBJ["csp-policies"];
+      is(policies.length, 1, "should be one policy");
+      let policy = policies[0];
+      is(
+        policy["script-src"],
+        "'unsafe-inline'",
+        "script-src directive matches"
+      );
+    }
+  );
+}
+
+add_setup(async function () {
+  // allow top level data: URI navigations, otherwise clicking data: link fails
+  await SpecialPowers.pushPrefEnv({
+    set: [["security.data_uri.block_toplevel_data_uri_navigations", false]],
+  });
+});
+
+add_task(async function test_data_csp_inheritance_regular_click() {
+  await BrowserTestUtils.withNewTab(HTML_URI, async function (browser) {
+    let loadPromise = BrowserTestUtils.browserLoaded(browser, false, DATA_URI);
+    // set the data href + simulate click
+    await setDataHrefOnLink(gBrowser.selectedBrowser, DATA_URI);
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#testlink",
+      {},
+      gBrowser.selectedBrowser
+    );
+    await loadPromise;
+    await verifyCSP("click()", gBrowser.selectedBrowser, DATA_URI);
+  });
+});
+
+add_task(async function test_data_csp_inheritance_ctrl_click() {
+  await BrowserTestUtils.withNewTab(HTML_URI, async function (browser) {
+    let loadPromise = BrowserTestUtils.waitForNewTab(gBrowser, DATA_URI, true);
+    // set the data href + simulate ctrl+click
+    await setDataHrefOnLink(gBrowser.selectedBrowser, DATA_URI);
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#testlink",
+      { ctrlKey: true, metaKey: true },
+      gBrowser.selectedBrowser
+    );
+    let tab = await loadPromise;
+    gBrowser.selectTabAtIndex(2);
+    await verifyCSP("ctrl-click()", gBrowser.selectedBrowser, DATA_URI);
+    await BrowserTestUtils.removeTab(tab);
+  });
+});
+
+add_task(
+  async function test_data_csp_inheritance_right_click_open_link_in_new_tab() {
+    await BrowserTestUtils.withNewTab(HTML_URI, async function (browser) {
+      let loadPromise = BrowserTestUtils.waitForNewTab(
+        gBrowser,
+        DATA_URI,
+        true
+      );
+      // set the data href + simulate right-click open link in tab
+      await setDataHrefOnLink(gBrowser.selectedBrowser, DATA_URI);
+      BrowserTestUtils.waitForEvent(document, "popupshown", false, event => {
+        // These are operations that must be executed synchronously with the event.
+        document.getElementById("context-openlinkintab").doCommand();
+        event.target.hidePopup();
+        return true;
+      });
+      BrowserTestUtils.synthesizeMouseAtCenter(
+        "#testlink",
+        { type: "contextmenu", button: 2 },
+        gBrowser.selectedBrowser
+      );
+
+      let tab = await loadPromise;
+      gBrowser.selectTabAtIndex(2);
+      await verifyCSP(
+        "right-click-open-in-new-tab()",
+        gBrowser.selectedBrowser,
+        DATA_URI
+      );
+      await BrowserTestUtils.removeTab(tab);
+    });
+  }
+);
diff --git a/docshell/test/browser/browser_fall_back_to_https.js b/docshell/test/browser/browser_fall_back_to_https.js
new file mode 100644
index 0000000000..7d64a781d1
--- /dev/null
+++ b/docshell/test/browser/browser_fall_back_to_https.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/*
+ * This test is for bug 1002724.
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=1002724
+ *
+ * When a user enters a host name or IP address in the URL bar, "http" is
+ * assumed.  If the host rejects connections on port 80, we try HTTPS as a
+ * fall-back and only fail if HTTPS connection fails.
+ *
+ * This tests that when a user enters "example.com", it attempts to load
+ * http://example.com:80 (not rejected), and when trying secureonly.example.com
+ * (which rejects connections on port 80), it fails then loads
+ * https://secureonly.example.com:443 instead.
+ */
+
+const { UrlbarTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/UrlbarTestUtils.sys.mjs"
+);
+
+const bug1002724_tests = [
+  {
+    original: "example.com",
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    expected: "http://example.com",
+    explanation: "Should load HTTP version of example.com",
+  },
+  {
+    original: "secureonly.example.com",
+    expected: "https://secureonly.example.com",
+    explanation:
+      "Should reject secureonly.example.com on HTTP but load the HTTPS version",
+  },
+];
+
+async function test_one(test_obj) {
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  gURLBar.focus();
+  gURLBar.value = test_obj.original;
+
+  let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser, false);
+  EventUtils.synthesizeKey("KEY_Enter");
+  await loadPromise;
+
+  ok(
+    tab.linkedBrowser.currentURI.spec.startsWith(test_obj.expected),
+    test_obj.explanation
+  );
+
+  BrowserTestUtils.removeTab(tab);
+}
+
+add_task(async function test_bug1002724() {
+  await SpecialPowers.pushPrefEnv(
+    // Disable HSTS preload just in case.
+    {
+      set: [
+        ["network.stricttransportsecurity.preloadlist", false],
+        ["network.dns.native-is-localhost", true],
+        ["dom.security.https_first_schemeless", false],
+      ],
+    }
+  );
+
+  for (let test of bug1002724_tests) {
+    await test_one(test);
+  }
+
+  // Test with HTTPS-First upgrading of schemeless enabled
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.security.https_first_schemeless", true]],
+  });
+
+  bug1002724_tests[0].expected = "https://example.com";
+  await test_one(bug1002724_tests[0]);
+});
diff --git a/docshell/test/browser/browser_frameloader_swap_with_bfcache.js b/docshell/test/browser/browser_frameloader_swap_with_bfcache.js
new file mode 100644
index 0000000000..d9f5a41573
--- /dev/null
+++ b/docshell/test/browser/browser_frameloader_swap_with_bfcache.js
@@ -0,0 +1,37 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+add_task(async function test() {
+  if (
+    !SpecialPowers.Services.appinfo.sessionHistoryInParent ||
+    !SpecialPowers.Services.prefs.getBoolPref("fission.bfcacheInParent")
+  ) {
+    ok(
+      true,
+      "This test is currently only for the bfcache in the parent process."
+    );
+    return;
+  }
+  const uri =
+    "data:text/html,<script>onpageshow = function(e) { document.documentElement.setAttribute('persisted', e.persisted); }; </script>";
+  let tab1 = await BrowserTestUtils.openNewForegroundTab(gBrowser, uri, true);
+  let browser1 = tab1.linkedBrowser;
+
+  let tab2 = await BrowserTestUtils.openNewForegroundTab(gBrowser, uri, true);
+  let browser2 = tab2.linkedBrowser;
+  BrowserTestUtils.startLoadingURIString(browser2, uri + "nextpage");
+  await BrowserTestUtils.browserLoaded(browser2, false);
+
+  gBrowser.swapBrowsersAndCloseOther(tab1, tab2);
+  is(tab1.linkedBrowser, browser1, "Tab's browser should stay the same.");
+  browser1.goBack(false);
+  await BrowserTestUtils.browserLoaded(browser1, false);
+  let persisted = await SpecialPowers.spawn(browser1, [], async function () {
+    return content.document.documentElement.getAttribute("persisted");
+  });
+
+  is(persisted, "false", "BFCache should be evicted when swapping browsers.");
+
+  BrowserTestUtils.removeTab(tab1);
+});
diff --git a/docshell/test/browser/browser_history_triggeringprincipal_viewsource.js b/docshell/test/browser/browser_history_triggeringprincipal_viewsource.js
new file mode 100644
index 0000000000..d542ef892c
--- /dev/null
+++ b/docshell/test/browser/browser_history_triggeringprincipal_viewsource.js
@@ -0,0 +1,88 @@
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com"
+);
+const HTML_URI = TEST_PATH + "dummy_page.html";
+const VIEW_SRC_URI = "view-source:" + HTML_URI;
+
+add_task(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.navigation.requireUserInteraction", false]],
+  });
+
+  info("load baseline html in new tab");
+  await BrowserTestUtils.withNewTab(HTML_URI, async function (aBrowser) {
+    is(
+      gBrowser.selectedBrowser.currentURI.spec,
+      HTML_URI,
+      "sanity check to make sure html loaded"
+    );
+
+    info("right-click -> view-source of html");
+    let vSrcCtxtMenu = document.getElementById("contentAreaContextMenu");
+    let popupPromise = BrowserTestUtils.waitForEvent(
+      vSrcCtxtMenu,
+      "popupshown"
+    );
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "body",
+      { type: "contextmenu", button: 2 },
+      aBrowser
+    );
+    await popupPromise;
+    let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, VIEW_SRC_URI);
+    let vSrcItem = vSrcCtxtMenu.querySelector("#context-viewsource");
+    vSrcCtxtMenu.activateItem(vSrcItem);
+    let tab = await tabPromise;
+    is(
+      gBrowser.selectedBrowser.currentURI.spec,
+      VIEW_SRC_URI,
+      "loading view-source of html succeeded"
+    );
+
+    info("load html file again before going .back()");
+    let loadPromise = BrowserTestUtils.browserLoaded(
+      tab.linkedBrowser,
+      false,
+      HTML_URI
+    );
+    await SpecialPowers.spawn(tab.linkedBrowser, [HTML_URI], HTML_URI => {
+      content.document.location = HTML_URI;
+    });
+    await loadPromise;
+    is(
+      gBrowser.selectedBrowser.currentURI.spec,
+      HTML_URI,
+      "loading html another time succeeded"
+    );
+
+    info(
+      "click .back() to view-source of html again and make sure the history entry has a triggeringPrincipal"
+    );
+    let backCtxtMenu = document.getElementById("contentAreaContextMenu");
+    popupPromise = BrowserTestUtils.waitForEvent(backCtxtMenu, "popupshown");
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "body",
+      { type: "contextmenu", button: 2 },
+      aBrowser
+    );
+    await popupPromise;
+    loadPromise = BrowserTestUtils.waitForContentEvent(
+      tab.linkedBrowser,
+      "pageshow"
+    );
+    let backItem = backCtxtMenu.querySelector("#context-back");
+    backCtxtMenu.activateItem(backItem);
+    await loadPromise;
+    is(
+      gBrowser.selectedBrowser.currentURI.spec,
+      VIEW_SRC_URI,
+      "clicking .back() to view-source of html succeeded"
+    );
+
+    BrowserTestUtils.removeTab(tab);
+  });
+});
diff --git a/docshell/test/browser/browser_isInitialDocument.js b/docshell/test/browser/browser_isInitialDocument.js
new file mode 100644
index 0000000000..03265c8e3e
--- /dev/null
+++ b/docshell/test/browser/browser_isInitialDocument.js
@@ -0,0 +1,319 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Tag every new WindowGlobalParent with an expando indicating whether or not
+// they were an initial document when they were created for the duration of this
+// test.
+function wasInitialDocumentObserver(subject) {
+  subject._test_wasInitialDocument = subject.isInitialDocument;
+}
+Services.obs.addObserver(wasInitialDocumentObserver, "window-global-created");
+SimpleTest.registerCleanupFunction(function () {
+  Services.obs.removeObserver(
+    wasInitialDocumentObserver,
+    "window-global-created"
+  );
+});
+
+add_task(async function new_about_blank_tab() {
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    is(
+      browser.browsingContext.currentWindowGlobal.isInitialDocument,
+      false,
+      "After loading an actual, final about:blank in the tab, the field is false"
+    );
+  });
+});
+
+add_task(async function iframe_initial_about_blank() {
+  await BrowserTestUtils.withNewTab(
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.com/document-builder.sjs?html=com",
+    async browser => {
+      info("Create an iframe without any explicit location");
+      await SpecialPowers.spawn(browser, [], async () => {
+        const iframe = content.document.createElement("iframe");
+        // Add the iframe to the DOM tree in order to be able to have its browsingContext
+        content.document.body.appendChild(iframe);
+        const { browsingContext } = iframe;
+
+        is(
+          iframe.contentDocument.isInitialDocument,
+          true,
+          "The field is true on just-created iframes"
+        );
+        let beforeLoadPromise = SpecialPowers.spawnChrome(
+          [browsingContext],
+          bc => [
+            bc.currentWindowGlobal.isInitialDocument,
+            bc.currentWindowGlobal._test_wasInitialDocument,
+          ]
+        );
+
+        await new Promise(resolve => {
+          iframe.addEventListener("load", resolve, { once: true });
+        });
+        is(
+          iframe.contentDocument.isInitialDocument,
+          false,
+          "The field is false after having loaded the final about:blank document"
+        );
+        let afterLoadPromise = SpecialPowers.spawnChrome(
+          [browsingContext],
+          bc => [
+            bc.currentWindowGlobal.isInitialDocument,
+            bc.currentWindowGlobal._test_wasInitialDocument,
+          ]
+        );
+
+        // Wait to await the parent process promises, so we can't miss the "load" event.
+        let [beforeIsInitial, beforeWasInitial] = await beforeLoadPromise;
+        is(beforeIsInitial, true, "before load is initial in parent");
+        is(beforeWasInitial, true, "before load was initial in parent");
+        let [afterIsInitial, afterWasInitial] = await afterLoadPromise;
+        is(afterIsInitial, false, "after load is not initial in parent");
+        is(afterWasInitial, true, "after load was initial in parent");
+        iframe.remove();
+      });
+
+      info("Create an iframe with a cross origin location");
+      const iframeBC = await SpecialPowers.spawn(browser, [], async () => {
+        const iframe = content.document.createElement("iframe");
+        await new Promise(resolve => {
+          iframe.addEventListener("load", resolve, { once: true });
+          iframe.src =
+            // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+            "http://example.org/document-builder.sjs?html=org-iframe";
+          content.document.body.appendChild(iframe);
+        });
+
+        return iframe.browsingContext;
+      });
+
+      is(
+        iframeBC.currentWindowGlobal.isInitialDocument,
+        false,
+        "The field is true after having loaded the final document"
+      );
+    }
+  );
+});
+
+add_task(async function window_open() {
+  async function testWindowOpen({ browser, args, isCrossOrigin, willLoad }) {
+    info(`Open popup with ${JSON.stringify(args)}`);
+    const onNewTab = BrowserTestUtils.waitForNewTab(
+      gBrowser,
+      args[0] || "about:blank"
+    );
+    await SpecialPowers.spawn(
+      browser,
+      [args, isCrossOrigin, willLoad],
+      async (args, crossOrigin, willLoad) => {
+        const win = content.window.open(...args);
+        is(
+          win.document.isInitialDocument,
+          true,
+          "The field is true right after calling window.open()"
+        );
+        let beforeLoadPromise = SpecialPowers.spawnChrome(
+          [win.browsingContext],
+          bc => [
+            bc.currentWindowGlobal.isInitialDocument,
+            bc.currentWindowGlobal._test_wasInitialDocument,
+          ]
+        );
+
+        // In cross origin, it is harder to watch for new document load, and if
+        // no argument is passed no load will happen.
+        if (!crossOrigin && willLoad) {
+          await new Promise(r =>
+            win.addEventListener("load", r, { once: true })
+          );
+          is(
+            win.document.isInitialDocument,
+            false,
+            "The field becomes false right after the popup document is loaded"
+          );
+        }
+
+        // Perform the await after the load to avoid missing it.
+        let [beforeIsInitial, beforeWasInitial] = await beforeLoadPromise;
+        is(beforeIsInitial, true, "before load is initial in parent");
+        is(beforeWasInitial, true, "before load was initial in parent");
+      }
+    );
+    const newTab = await onNewTab;
+    const windowGlobal =
+      newTab.linkedBrowser.browsingContext.currentWindowGlobal;
+    if (willLoad) {
+      is(
+        windowGlobal.isInitialDocument,
+        false,
+        "The field is false in the parent process after having loaded the final document"
+      );
+    } else {
+      is(
+        windowGlobal.isInitialDocument,
+        true,
+        "The field remains true in the parent process as nothing will be loaded"
+      );
+    }
+    BrowserTestUtils.removeTab(newTab);
+  }
+
+  await BrowserTestUtils.withNewTab(
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.com/document-builder.sjs?html=com",
+    async browser => {
+      info("Use window.open() with cross-origin document");
+      await testWindowOpen({
+        browser,
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        args: ["http://example.org/document-builder.sjs?html=org-popup"],
+        isCrossOrigin: true,
+        willLoad: true,
+      });
+
+      info("Use window.open() with same-origin document");
+      await testWindowOpen({
+        browser,
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        args: ["http://example.com/document-builder.sjs?html=com-popup"],
+        isCrossOrigin: false,
+        willLoad: true,
+      });
+
+      info("Use window.open() with final about:blank document");
+      await testWindowOpen({
+        browser,
+        args: ["about:blank"],
+        isCrossOrigin: false,
+        willLoad: true,
+      });
+
+      info("Use window.open() with no argument");
+      await testWindowOpen({
+        browser,
+        args: [],
+        isCrossOrigin: false,
+        willLoad: false,
+      });
+    }
+  );
+});
+
+add_task(async function document_open() {
+  await BrowserTestUtils.withNewTab(
+    // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+    "http://example.com/document-builder.sjs?html=com",
+    async browser => {
+      is(browser.browsingContext.currentWindowGlobal.isInitialDocument, false);
+      await SpecialPowers.spawn(browser, [], async () => {
+        const iframe = content.document.createElement("iframe");
+        // Add the iframe to the DOM tree in order to be able to have its browsingContext
+        content.document.body.appendChild(iframe);
+        const { browsingContext } = iframe;
+
+        // Check the state before the call in both parent and content.
+        is(
+          iframe.contentDocument.isInitialDocument,
+          true,
+          "Is an initial document before calling document.open"
+        );
+        let beforeOpenParentPromise = SpecialPowers.spawnChrome(
+          [browsingContext],
+          bc => [
+            bc.currentWindowGlobal.isInitialDocument,
+            bc.currentWindowGlobal._test_wasInitialDocument,
+            bc.currentWindowGlobal.innerWindowId,
+          ]
+        );
+
+        // Run the `document.open` call with reduced permissions.
+        iframe.contentWindow.eval(`
+          document.open();
+          document.write("new document");
+          document.close();
+        `);
+
+        is(
+          iframe.contentDocument.isInitialDocument,
+          false,
+          "Is no longer an initial document after calling document.open"
+        );
+        let [afterIsInitial, afterWasInitial, afterID] =
+          await SpecialPowers.spawnChrome([browsingContext], bc => [
+            bc.currentWindowGlobal.isInitialDocument,
+            bc.currentWindowGlobal._test_wasInitialDocument,
+            bc.currentWindowGlobal.innerWindowId,
+          ]);
+        let [beforeIsInitial, beforeWasInitial, beforeID] =
+          await beforeOpenParentPromise;
+        is(beforeIsInitial, true, "Should be initial before in the parent");
+        is(beforeWasInitial, true, "Was initial before in the parent");
+        is(afterIsInitial, false, "Should not be initial after in the parent");
+        is(afterWasInitial, true, "Was initial after in the parent");
+        is(beforeID, afterID, "Should be the same WindowGlobalParent");
+      });
+    }
+  );
+});
+
+add_task(async function windowless_browser() {
+  info("Create a Windowless browser");
+  const browser = Services.appShell.createWindowlessBrowser(false);
+  const { browsingContext } = browser;
+  is(
+    browsingContext.currentWindowGlobal.isInitialDocument,
+    true,
+    "The field is true for a freshly created WindowlessBrowser"
+  );
+  is(
+    browser.currentURI.spec,
+    "about:blank",
+    "The location is immediately set to about:blank"
+  );
+
+  const principal = Services.scriptSecurityManager.getSystemPrincipal();
+  browser.docShell.createAboutBlankDocumentViewer(principal, principal);
+  is(
+    browsingContext.currentWindowGlobal.isInitialDocument,
+    false,
+    "The field becomes false when creating an artificial blank document"
+  );
+
+  info("Load a final about:blank document in it");
+  const onLocationChange = new Promise(resolve => {
+    let wpl = {
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIWebProgressListener",
+        "nsISupportsWeakReference",
+      ]),
+      onLocationChange() {
+        browsingContext.webProgress.removeProgressListener(
+          wpl,
+          Ci.nsIWebProgress.NOTIFY_ALL
+        );
+        resolve();
+      },
+    };
+    browsingContext.webProgress.addProgressListener(
+      wpl,
+      Ci.nsIWebProgress.NOTIFY_ALL
+    );
+  });
+  browser.loadURI(Services.io.newURI("about:blank"), {
+    triggeringPrincipal: principal,
+  });
+  info("Wait for the location change");
+  await onLocationChange;
+  is(
+    browsingContext.currentWindowGlobal.isInitialDocument,
+    false,
+    "The field is false after the location change event"
+  );
+  browser.close();
+});
diff --git a/docshell/test/browser/browser_loadURI_postdata.js b/docshell/test/browser/browser_loadURI_postdata.js
new file mode 100644
index 0000000000..b2dbb7a641
--- /dev/null
+++ b/docshell/test/browser/browser_loadURI_postdata.js
@@ -0,0 +1,42 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const gPostData = "postdata=true";
+const gUrl =
+  "http://mochi.test:8888/browser/docshell/test/browser/print_postdata.sjs";
+
+add_task(async function test_loadURI_persists_postData() {
+  waitForExplicitFinish();
+
+  let tab = (gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser));
+  registerCleanupFunction(function () {
+    gBrowser.removeTab(tab);
+  });
+
+  var dataStream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(
+    Ci.nsIStringInputStream
+  );
+  dataStream.data = gPostData;
+
+  var postStream = Cc[
+    "@mozilla.org/network/mime-input-stream;1"
+  ].createInstance(Ci.nsIMIMEInputStream);
+  postStream.addHeader("Content-Type", "application/x-www-form-urlencoded");
+  postStream.setData(dataStream);
+  var systemPrincipal = Cc["@mozilla.org/systemprincipal;1"].getService(
+    Ci.nsIPrincipal
+  );
+
+  tab.linkedBrowser.loadURI(Services.io.newURI(gUrl), {
+    triggeringPrincipal: systemPrincipal,
+    postData: postStream,
+  });
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser, false, gUrl);
+  let body = await SpecialPowers.spawn(
+    tab.linkedBrowser,
+    [],
+    () => content.document.body.textContent
+  );
+  is(body, gPostData, "post data was submitted correctly");
+  finish();
+});
diff --git a/docshell/test/browser/browser_multiple_pushState.js b/docshell/test/browser/browser_multiple_pushState.js
new file mode 100644
index 0000000000..5d07747543
--- /dev/null
+++ b/docshell/test/browser/browser_multiple_pushState.js
@@ -0,0 +1,25 @@
+add_task(async function test_multiple_pushState() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url:
+        // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+        "http://example.org/browser/docshell/test/browser/file_multiple_pushState.html",
+    },
+    async function (browser) {
+      // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+      const kExpected = "http://example.org/bar/ABC/DEF?key=baz";
+
+      let contentLocation = await SpecialPowers.spawn(
+        browser,
+        [],
+        async function () {
+          return content.document.location.href;
+        }
+      );
+
+      is(contentLocation, kExpected);
+      is(browser.documentURI.spec, kExpected);
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_onbeforeunload_frame.js b/docshell/test/browser/browser_onbeforeunload_frame.js
new file mode 100644
index 0000000000..d697af718d
--- /dev/null
+++ b/docshell/test/browser/browser_onbeforeunload_frame.js
@@ -0,0 +1,45 @@
+"use strict";
+
+// We need to test a lot of permutations here, and there isn't any sensible way
+// to split them up or run them faster.
+requestLongerTimeout(12);
+
+Services.scriptloader.loadSubScript(
+  getRootDirectory(gTestPath) + "head_browser_onbeforeunload.js",
+  this
+);
+
+add_task(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.require_user_interaction_for_beforeunload", false]],
+  });
+
+  for (let actions of PERMUTATIONS) {
+    info(
+      `Testing frame actions: [${actions.map(action =>
+        ACTION_NAMES.get(action)
+      )}]`
+    );
+
+    for (let startIdx = 0; startIdx < FRAMES.length; startIdx++) {
+      info(`Testing content reload from frame ${startIdx}`);
+
+      await doTest(actions, startIdx, (tab, frames) => {
+        return SpecialPowers.spawn(frames[startIdx], [], () => {
+          let eventLoopSpun = false;
+          SpecialPowers.Services.tm.dispatchToMainThread(() => {
+            eventLoopSpun = true;
+          });
+
+          content.location.reload();
+
+          return { eventLoopSpun };
+        });
+      });
+    }
+  }
+});
+
+add_task(async function cleanup() {
+  await TabPool.cleanup();
+});
diff --git a/docshell/test/browser/browser_onbeforeunload_navigation.js b/docshell/test/browser/browser_onbeforeunload_navigation.js
new file mode 100644
index 0000000000..23dc3b528e
--- /dev/null
+++ b/docshell/test/browser/browser_onbeforeunload_navigation.js
@@ -0,0 +1,165 @@
+"use strict";
+
+const TEST_PAGE =
+  "http://mochi.test:8888/browser/docshell/test/browser/file_bug1046022.html";
+const TARGETED_PAGE =
+  "data:text/html," +
+  encodeURIComponent("<body>Shouldn't be seeing this</body>");
+
+const { PromptTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PromptTestUtils.sys.mjs"
+);
+
+var loadStarted = false;
+var tabStateListener = {
+  resolveLoad: null,
+  expectLoad: null,
+
+  onStateChange(webprogress, request, flags, status) {
+    const WPL = Ci.nsIWebProgressListener;
+    if (flags & WPL.STATE_IS_WINDOW) {
+      if (flags & WPL.STATE_START) {
+        loadStarted = true;
+      } else if (flags & WPL.STATE_STOP) {
+        let url = request.QueryInterface(Ci.nsIChannel).URI.spec;
+        is(url, this.expectLoad, "Should only see expected document loads");
+        if (url == this.expectLoad) {
+          this.resolveLoad();
+        }
+      }
+    }
+  },
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+function promiseLoaded(url, callback) {
+  if (tabStateListener.expectLoad) {
+    throw new Error("Can't wait for multiple loads at once");
+  }
+  tabStateListener.expectLoad = url;
+  return new Promise(resolve => {
+    tabStateListener.resolveLoad = resolve;
+    if (callback) {
+      callback();
+    }
+  }).then(() => {
+    tabStateListener.expectLoad = null;
+    tabStateListener.resolveLoad = null;
+  });
+}
+
+function promiseStayOnPagePrompt(browser, acceptNavigation) {
+  return PromptTestUtils.handleNextPrompt(
+    browser,
+    { modalType: Services.prompt.MODAL_TYPE_CONTENT, promptType: "confirmEx" },
+    { buttonNumClick: acceptNavigation ? 0 : 1 }
+  );
+}
+
+add_task(async function test() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.require_user_interaction_for_beforeunload", false]],
+  });
+
+  let testTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    TEST_PAGE,
+    false,
+    true
+  );
+  let browser = testTab.linkedBrowser;
+  browser.addProgressListener(
+    tabStateListener,
+    Ci.nsIWebProgress.NOTIFY_STATE_WINDOW
+  );
+
+  const NUM_TESTS = 7;
+  await SpecialPowers.spawn(browser, [NUM_TESTS], testCount => {
+    let { testFns } = this.content.wrappedJSObject;
+    Assert.equal(
+      testFns.length,
+      testCount,
+      "Should have the correct number of test functions"
+    );
+  });
+
+  for (let allowNavigation of [false, true]) {
+    for (let i = 0; i < NUM_TESTS; i++) {
+      info(
+        `Running test ${i} with navigation ${
+          allowNavigation ? "allowed" : "forbidden"
+        }`
+      );
+
+      if (allowNavigation) {
+        // If we're allowing navigations, we need to re-load the test
+        // page after each test, since the tests will each navigate away
+        // from it.
+        await promiseLoaded(TEST_PAGE, () => {
+          browser.loadURI(Services.io.newURI(TEST_PAGE), {
+            triggeringPrincipal: document.nodePrincipal,
+          });
+        });
+      }
+
+      let promptPromise = promiseStayOnPagePrompt(browser, allowNavigation);
+      let loadPromise;
+      if (allowNavigation) {
+        loadPromise = promiseLoaded(TARGETED_PAGE);
+      }
+
+      let winID = await SpecialPowers.spawn(
+        browser,
+        [i, TARGETED_PAGE],
+        (testIdx, url) => {
+          let { testFns } = this.content.wrappedJSObject;
+          this.content.onbeforeunload = testFns[testIdx];
+          this.content.location = url;
+          return this.content.windowGlobalChild.innerWindowId;
+        }
+      );
+
+      await promptPromise;
+      await loadPromise;
+
+      if (allowNavigation) {
+        await SpecialPowers.spawn(
+          browser,
+          [TARGETED_PAGE, winID],
+          (url, winID) => {
+            this.content.onbeforeunload = null;
+            Assert.equal(
+              this.content.location.href,
+              url,
+              "Page should have navigated to the correct URL"
+            );
+            Assert.notEqual(
+              this.content.windowGlobalChild.innerWindowId,
+              winID,
+              "Page should have a new inner window"
+            );
+          }
+        );
+      } else {
+        await SpecialPowers.spawn(browser, [TEST_PAGE, winID], (url, winID) => {
+          this.content.onbeforeunload = null;
+          Assert.equal(
+            this.content.location.href,
+            url,
+            "Page should have the same URL"
+          );
+          Assert.equal(
+            this.content.windowGlobalChild.innerWindowId,
+            winID,
+            "Page should have the same inner window"
+          );
+        });
+      }
+    }
+  }
+
+  gBrowser.removeTab(testTab);
+});
diff --git a/docshell/test/browser/browser_onbeforeunload_parent.js b/docshell/test/browser/browser_onbeforeunload_parent.js
new file mode 100644
index 0000000000..72c5004334
--- /dev/null
+++ b/docshell/test/browser/browser_onbeforeunload_parent.js
@@ -0,0 +1,48 @@
+"use strict";
+
+// We need to test a lot of permutations here, and there isn't any sensible way
+// to split them up or run them faster.
+requestLongerTimeout(6);
+
+Services.scriptloader.loadSubScript(
+  getRootDirectory(gTestPath) + "head_browser_onbeforeunload.js",
+  this
+);
+
+add_task(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.require_user_interaction_for_beforeunload", false]],
+  });
+
+  for (let actions of PERMUTATIONS) {
+    info(
+      `Testing frame actions: [${actions.map(action =>
+        ACTION_NAMES.get(action)
+      )}]`
+    );
+
+    info(`Testing tab close from parent process`);
+    await doTest(actions, -1, (tab, frames) => {
+      let eventLoopSpun = false;
+      Services.tm.dispatchToMainThread(() => {
+        eventLoopSpun = true;
+      });
+
+      BrowserTestUtils.removeTab(tab);
+
+      let result = { eventLoopSpun };
+
+      // Make an extra couple of trips through the event loop to give us time
+      // to process SpecialPowers.spawn responses before resolving.
+      return new Promise(resolve => {
+        executeSoon(() => {
+          executeSoon(() => resolve(result));
+        });
+      });
+    });
+  }
+});
+
+add_task(async function cleanup() {
+  await TabPool.cleanup();
+});
diff --git a/docshell/test/browser/browser_onunload_stop.js b/docshell/test/browser/browser_onunload_stop.js
new file mode 100644
index 0000000000..e5bacfee06
--- /dev/null
+++ b/docshell/test/browser/browser_onunload_stop.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE_1 =
+  "http://mochi.test:8888/browser/docshell/test/browser/dummy_page.html";
+
+const TEST_PAGE_2 =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://example.com/browser/docshell/test/browser/dummy_page.html";
+
+add_task(async function test() {
+  await BrowserTestUtils.withNewTab(TEST_PAGE_1, async function (browser) {
+    let loaded = BrowserTestUtils.browserLoaded(browser, false, TEST_PAGE_2);
+    await SpecialPowers.spawn(browser, [], () => {
+      content.addEventListener("unload", e => e.currentTarget.stop(), true);
+    });
+    BrowserTestUtils.startLoadingURIString(browser, TEST_PAGE_2);
+    await loaded;
+    ok(true, "Page loaded successfully");
+  });
+});
diff --git a/docshell/test/browser/browser_overlink.js b/docshell/test/browser/browser_overlink.js
new file mode 100644
index 0000000000..f9371d59ce
--- /dev/null
+++ b/docshell/test/browser/browser_overlink.js
@@ -0,0 +1,33 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  UrlbarTestUtils: "resource://testing-common/UrlbarTestUtils.sys.mjs",
+});
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "https://example.com"
+);
+
+add_task(async function test_stripAuthCredentials() {
+  await BrowserTestUtils.withNewTab(
+    TEST_PATH + "overlink_test.html",
+    async function (browser) {
+      await SpecialPowers.spawn(browser, [], function () {
+        content.document.getElementById("link").focus();
+      });
+
+      await TestUtils.waitForCondition(
+        () =>
+          XULBrowserWindow.overLink ==
+          UrlbarTestUtils.trimURL("https://example.com"),
+        "Overlink should be missing auth credentials"
+      );
+
+      ok(true, "Test successful");
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_platform_emulation.js b/docshell/test/browser/browser_platform_emulation.js
new file mode 100644
index 0000000000..017b615e15
--- /dev/null
+++ b/docshell/test/browser/browser_platform_emulation.js
@@ -0,0 +1,70 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const URL = "data:text/html;charset=utf-8,<iframe id='test-iframe'></iframe>";
+
+async function contentTaskNoOverride() {
+  let docshell = docShell;
+  is(
+    docshell.browsingContext.customPlatform,
+    "",
+    "There should initially be no customPlatform"
+  );
+}
+
+async function contentTaskOverride() {
+  let docshell = docShell;
+  is(
+    docshell.browsingContext.customPlatform,
+    "foo",
+    "The platform should be changed to foo"
+  );
+
+  is(
+    content.navigator.platform,
+    "foo",
+    "The platform should be changed to foo"
+  );
+
+  let frameWin = content.document.querySelector("#test-iframe").contentWindow;
+  is(
+    frameWin.navigator.platform,
+    "foo",
+    "The platform should be passed on to frames."
+  );
+
+  let newFrame = content.document.createElement("iframe");
+  content.document.body.appendChild(newFrame);
+
+  let newFrameWin = newFrame.contentWindow;
+  is(
+    newFrameWin.navigator.platform,
+    "foo",
+    "Newly created frames should use the new platform"
+  );
+
+  newFrameWin.location.reload();
+  await ContentTaskUtils.waitForEvent(newFrame, "load");
+
+  is(
+    newFrameWin.navigator.platform,
+    "foo",
+    "New platform should persist across reloads"
+  );
+}
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: URL },
+    async function (browser) {
+      await SpecialPowers.spawn(browser, [], contentTaskNoOverride);
+
+      let browsingContext = BrowserTestUtils.getBrowsingContextFrom(browser);
+      browsingContext.customPlatform = "foo";
+
+      await SpecialPowers.spawn(browser, [], contentTaskOverride);
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_search_notification.js b/docshell/test/browser/browser_search_notification.js
new file mode 100644
index 0000000000..f98ad22a40
--- /dev/null
+++ b/docshell/test/browser/browser_search_notification.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { SearchTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/SearchTestUtils.sys.mjs"
+);
+
+SearchTestUtils.init(this);
+
+add_task(async function () {
+  // Our search would be handled by the urlbar normally and not by the docshell,
+  // thus we must force going through dns first, so that the urlbar thinks
+  // the value may be a url, and asks the docshell to visit it.
+  // On NS_ERROR_UNKNOWN_HOST the docshell will fix it up.
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.fixup.dns_first_for_single_words", true]],
+  });
+  const kSearchEngineID = "test_urifixup_search_engine";
+  await SearchTestUtils.installSearchExtension(
+    {
+      name: kSearchEngineID,
+      search_url: "http://localhost/",
+      search_url_get_params: "search={searchTerms}",
+    },
+    { setAsDefault: true }
+  );
+
+  let selectedName = (await Services.search.getDefault()).name;
+  Assert.equal(
+    selectedName,
+    kSearchEngineID,
+    "Check fake search engine is selected"
+  );
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+  gBrowser.selectedTab = tab;
+
+  gURLBar.value = "firefox";
+  gURLBar.handleCommand();
+
+  let [subject, data] = await TestUtils.topicObserved("keyword-search");
+
+  let engine = subject.QueryInterface(Ci.nsISupportsString).data;
+
+  Assert.equal(engine, kSearchEngineID, "Should be the search engine id");
+  Assert.equal(data, "firefox", "Notification data is search term.");
+
+  gBrowser.removeTab(tab);
+});
diff --git a/docshell/test/browser/browser_tab_replace_while_loading.js b/docshell/test/browser/browser_tab_replace_while_loading.js
new file mode 100644
index 0000000000..3c85f72192
--- /dev/null
+++ b/docshell/test/browser/browser_tab_replace_while_loading.js
@@ -0,0 +1,83 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/* Test for bug 1578379. */
+
+add_task(async function test_window_open_about_blank() {
+  const URL =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_open_about_blank.html";
+  let firstTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, URL);
+  let promiseTabOpened = BrowserTestUtils.waitForNewTab(
+    gBrowser,
+    "about:blank"
+  );
+
+  info("Opening about:blank using a click");
+  await SpecialPowers.spawn(firstTab.linkedBrowser, [""], async function () {
+    content.document.querySelector("#open").click();
+  });
+
+  info("Waiting for the second tab to be opened");
+  let secondTab = await promiseTabOpened;
+
+  info("Detaching tab");
+  let windowOpenedPromise = BrowserTestUtils.waitForNewWindow();
+  gBrowser.replaceTabWithWindow(secondTab);
+  let win = await windowOpenedPromise;
+
+  info("Asserting document is visible");
+  let tab = win.gBrowser.selectedTab;
+  await SpecialPowers.spawn(tab.linkedBrowser, [""], async function () {
+    is(
+      content.document.visibilityState,
+      "visible",
+      "Document should be visible"
+    );
+  });
+
+  await BrowserTestUtils.closeWindow(win);
+  await BrowserTestUtils.removeTab(firstTab);
+});
+
+add_task(async function test_detach_loading_page() {
+  const URL =
+    "http://mochi.test:8888/browser/docshell/test/browser/file_slow_load.sjs";
+  // Open a dummy tab so that detaching the second tab works.
+  let dummyTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  let slowLoadingTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    URL,
+    /* waitForLoad = */ false
+  );
+
+  info("Wait for content document to be created");
+  await BrowserTestUtils.waitForCondition(async function () {
+    return SpecialPowers.spawn(
+      slowLoadingTab.linkedBrowser,
+      [URL],
+      async function (url) {
+        return content.document.documentURI == url;
+      }
+    );
+  });
+
+  info("Detaching tab");
+  let windowOpenedPromise = BrowserTestUtils.waitForNewWindow();
+  gBrowser.replaceTabWithWindow(slowLoadingTab);
+  let win = await windowOpenedPromise;
+
+  info("Asserting document is visible");
+  let tab = win.gBrowser.selectedTab;
+  await SpecialPowers.spawn(tab.linkedBrowser, [""], async function () {
+    is(content.document.readyState, "loading");
+    is(content.document.visibilityState, "visible");
+  });
+
+  await BrowserTestUtils.closeWindow(win);
+  await BrowserTestUtils.removeTab(dummyTab);
+});
diff --git a/docshell/test/browser/browser_tab_touch_events.js b/docshell/test/browser/browser_tab_touch_events.js
new file mode 100644
index 0000000000..c73b01e45c
--- /dev/null
+++ b/docshell/test/browser/browser_tab_touch_events.js
@@ -0,0 +1,75 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function () {
+  const URI = "data:text/html;charset=utf-8,<iframe id='test-iframe'></iframe>";
+
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: URI },
+    async function (browser) {
+      await SpecialPowers.spawn(browser, [], test_init);
+
+      browser.browsingContext.touchEventsOverride = "disabled";
+
+      await SpecialPowers.spawn(browser, [], test_body);
+    }
+  );
+});
+
+async function test_init() {
+  is(
+    content.browsingContext.touchEventsOverride,
+    "none",
+    "touchEventsOverride flag should be initially set to NONE"
+  );
+}
+
+async function test_body() {
+  let bc = content.browsingContext;
+  is(
+    bc.touchEventsOverride,
+    "disabled",
+    "touchEventsOverride flag should be changed to DISABLED"
+  );
+
+  let frameWin = content.document.querySelector("#test-iframe").contentWindow;
+  bc = frameWin.browsingContext;
+  is(
+    bc.touchEventsOverride,
+    "disabled",
+    "touchEventsOverride flag should be passed on to frames."
+  );
+
+  let newFrame = content.document.createElement("iframe");
+  content.document.body.appendChild(newFrame);
+
+  let newFrameWin = newFrame.contentWindow;
+  bc = newFrameWin.browsingContext;
+  is(
+    bc.touchEventsOverride,
+    "disabled",
+    "Newly created frames should use the new touchEventsOverride flag"
+  );
+
+  // Wait for the non-transient about:blank to load.
+  await ContentTaskUtils.waitForEvent(newFrame, "load");
+  newFrameWin = newFrame.contentWindow;
+  bc = newFrameWin.browsingContext;
+  is(
+    bc.touchEventsOverride,
+    "disabled",
+    "Newly created frames should use the new touchEventsOverride flag"
+  );
+
+  newFrameWin.location.reload();
+  await ContentTaskUtils.waitForEvent(newFrame, "load");
+  newFrameWin = newFrame.contentWindow;
+  bc = newFrameWin.browsingContext;
+  is(
+    bc.touchEventsOverride,
+    "disabled",
+    "New touchEventsOverride flag should persist across reloads"
+  );
+}
diff --git a/docshell/test/browser/browser_targetTopLevelLinkClicksToBlank.js b/docshell/test/browser/browser_targetTopLevelLinkClicksToBlank.js
new file mode 100644
index 0000000000..9d5a91bef9
--- /dev/null
+++ b/docshell/test/browser/browser_targetTopLevelLinkClicksToBlank.js
@@ -0,0 +1,285 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * This test exercises the behaviour where user-initiated link clicks on
+ * the top-level document result in pageloads in a _blank target in a new
+ * browser window.
+ */
+
+const TEST_PAGE = "https://example.com/browser/";
+const TEST_PAGE_2 = "https://example.com/browser/components/";
+const TEST_IFRAME_PAGE =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "https://example.com"
+  ) + "dummy_iframe_page.html";
+
+// There is an <a> element with this href=".." in the TEST_PAGE
+// that we will click, which should take us up a level.
+const LINK_URL = "https://example.com/";
+
+/**
+ * Test that a user-initiated link click results in targeting to a new
+ * <browser> element, and that this properly sets the referrer on the newly
+ * loaded document.
+ */
+add_task(async function target_to_new_blank_browser() {
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  let originalTab = win.gBrowser.selectedTab;
+  let originalBrowser = originalTab.linkedBrowser;
+  BrowserTestUtils.startLoadingURIString(originalBrowser, TEST_PAGE);
+  await BrowserTestUtils.browserLoaded(originalBrowser, false, TEST_PAGE);
+
+  // Now set the targetTopLevelLinkClicksToBlank property to true, since it
+  // defaults to false.
+  originalBrowser.browsingContext.targetTopLevelLinkClicksToBlank = true;
+
+  let newTabPromise = BrowserTestUtils.waitForNewTab(win.gBrowser, LINK_URL);
+  await SpecialPowers.spawn(originalBrowser, [], async () => {
+    let anchor = content.document.querySelector(`a[href=".."]`);
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      anchor.click();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  let newTab = await newTabPromise;
+  let newBrowser = newTab.linkedBrowser;
+
+  Assert.ok(
+    originalBrowser !== newBrowser,
+    "A new browser should have been created."
+  );
+  await SpecialPowers.spawn(newBrowser, [TEST_PAGE], async referrer => {
+    Assert.equal(
+      content.document.referrer,
+      referrer,
+      "Should have gotten the right referrer set"
+    );
+  });
+  await BrowserTestUtils.switchTab(win.gBrowser, originalTab);
+  BrowserTestUtils.removeTab(newTab);
+
+  // Now do the same thing with a subframe targeting "_top". This should also
+  // get redirected to "_blank".
+  BrowserTestUtils.startLoadingURIString(originalBrowser, TEST_IFRAME_PAGE);
+  await BrowserTestUtils.browserLoaded(
+    originalBrowser,
+    false,
+    TEST_IFRAME_PAGE
+  );
+
+  newTabPromise = BrowserTestUtils.waitForNewTab(win.gBrowser, LINK_URL);
+  let frameBC1 = originalBrowser.browsingContext.children[0];
+  Assert.ok(frameBC1, "Should have found a subframe BrowsingContext");
+
+  await SpecialPowers.spawn(frameBC1, [LINK_URL], async linkUrl => {
+    let anchor = content.document.createElement("a");
+    anchor.setAttribute("href", linkUrl);
+    anchor.setAttribute("target", "_top");
+    content.document.body.appendChild(anchor);
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      anchor.click();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  newTab = await newTabPromise;
+  newBrowser = newTab.linkedBrowser;
+
+  Assert.ok(
+    originalBrowser !== newBrowser,
+    "A new browser should have been created."
+  );
+  await SpecialPowers.spawn(
+    newBrowser,
+    [frameBC1.currentURI.spec],
+    async referrer => {
+      Assert.equal(
+        content.document.referrer,
+        referrer,
+        "Should have gotten the right referrer set"
+      );
+    }
+  );
+  await BrowserTestUtils.switchTab(win.gBrowser, originalTab);
+  BrowserTestUtils.removeTab(newTab);
+
+  await BrowserTestUtils.closeWindow(win);
+});
+
+/**
+ * Test that we don't target to _blank loads caused by:
+ * 1. POST requests
+ * 2. Any load that isn't "normal" (in the nsIDocShell.LOAD_CMD_NORMAL sense)
+ * 3. Any loads that are caused by location.replace
+ * 4. Any loads that were caused by setting location.href
+ * 5. Link clicks fired without user interaction.
+ */
+add_task(async function skip_blank_target_for_some_loads() {
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  let currentBrowser = win.gBrowser.selectedBrowser;
+  BrowserTestUtils.startLoadingURIString(currentBrowser, TEST_PAGE);
+  await BrowserTestUtils.browserLoaded(currentBrowser, false, TEST_PAGE);
+
+  // Now set the targetTopLevelLinkClicksToBlank property to true, since it
+  // defaults to false.
+  currentBrowser.browsingContext.targetTopLevelLinkClicksToBlank = true;
+
+  let ensureSingleBrowser = () => {
+    Assert.equal(
+      win.gBrowser.browsers.length,
+      1,
+      "There should only be 1 browser."
+    );
+
+    Assert.ok(
+      currentBrowser.browsingContext.targetTopLevelLinkClicksToBlank,
+      "Should still be targeting top-level clicks to _blank"
+    );
+  };
+
+  // First we'll test a POST request
+  let sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE
+  );
+  await SpecialPowers.spawn(currentBrowser, [], async () => {
+    let doc = content.document;
+    let form = doc.createElement("form");
+    form.setAttribute("method", "post");
+    doc.body.appendChild(form);
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      form.submit();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  // Next, we'll try a non-normal load - specifically, we'll try a reload.
+  // Since we've got a page loaded via a POST request, an attempt to reload
+  // will cause the "repost" dialog to appear, so we temporarily allow the
+  // repost to go through with the always_accept testing pref.
+  await SpecialPowers.pushPrefEnv({
+    set: [["dom.confirm_repost.testing.always_accept", true]],
+  });
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE
+  );
+  await SpecialPowers.spawn(currentBrowser, [], async () => {
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      content.location.reload();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+  await SpecialPowers.popPrefEnv();
+
+  // Next, we'll try a location.replace
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE_2
+  );
+  await SpecialPowers.spawn(currentBrowser, [TEST_PAGE_2], async page2 => {
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      content.location.replace(page2);
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  // Finally we'll try setting location.href
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE
+  );
+  await SpecialPowers.spawn(currentBrowser, [TEST_PAGE], async page1 => {
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      content.location.href = page1;
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  // Now that we're back at TEST_PAGE, let's try a scripted link click. This
+  // shouldn't target to _blank.
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    LINK_URL
+  );
+  await SpecialPowers.spawn(currentBrowser, [], async () => {
+    let anchor = content.document.querySelector(`a[href=".."]`);
+    anchor.click();
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  // A javascript:void(0); link should also not target to _blank.
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE
+  );
+  await SpecialPowers.spawn(currentBrowser, [TEST_PAGE], async newPageURL => {
+    let anchor = content.document.querySelector(`a[href=".."]`);
+    anchor.href = "javascript:void(0);";
+    anchor.addEventListener("click", e => {
+      content.location.href = newPageURL;
+    });
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      anchor.click();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  // Let's also try a non-void javascript: location.
+  sameBrowserLoad = BrowserTestUtils.browserLoaded(
+    currentBrowser,
+    false,
+    TEST_PAGE
+  );
+  await SpecialPowers.spawn(currentBrowser, [TEST_PAGE], async newPageURL => {
+    let anchor = content.document.querySelector(`a[href=".."]`);
+    anchor.href = `javascript:"string-to-navigate-to"`;
+    anchor.addEventListener("click", e => {
+      content.location.href = newPageURL;
+    });
+    let userInput = content.windowUtils.setHandlingUserInput(true);
+    try {
+      anchor.click();
+    } finally {
+      userInput.destruct();
+    }
+  });
+  await sameBrowserLoad;
+  ensureSingleBrowser();
+
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/docshell/test/browser/browser_title_in_session_history.js b/docshell/test/browser/browser_title_in_session_history.js
new file mode 100644
index 0000000000..bdcbbb7dfe
--- /dev/null
+++ b/docshell/test/browser/browser_title_in_session_history.js
@@ -0,0 +1,63 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test() {
+  const TEST_PAGE =
+    getRootDirectory(gTestPath).replace(
+      "chrome://mochitests/content",
+      "https://example.com"
+    ) + "dummy_page.html";
+  await BrowserTestUtils.withNewTab(TEST_PAGE, async browser => {
+    let titles = await ContentTask.spawn(browser, null, () => {
+      return new Promise(resolve => {
+        let titles = [];
+        content.document.body.innerHTML = "<div id='foo'>foo</div>";
+        content.document.title = "Initial";
+        content.history.pushState("1", "1", "1");
+        content.document.title = "1";
+        content.history.pushState("2", "2", "2");
+        content.document.title = "2";
+        content.location.hash = "hash";
+        content.document.title = "3-hash";
+        content.addEventListener(
+          "popstate",
+          () => {
+            content.addEventListener(
+              "popstate",
+              () => {
+                titles.push(content.document.title);
+                resolve(titles);
+              },
+              { once: true }
+            );
+
+            titles.push(content.document.title);
+            // Test going forward a few steps.
+            content.history.go(2);
+          },
+          { once: true }
+        );
+        // Test going back a few steps.
+        content.history.go(-3);
+      });
+    });
+    is(
+      titles[0],
+      "3-hash",
+      "Document.title should have the value to which it was last time set."
+    );
+    is(
+      titles[1],
+      "3-hash",
+      "Document.title should have the value to which it was last time set."
+    );
+    let sh = browser.browsingContext.sessionHistory;
+    let count = sh.count;
+    is(sh.getEntryAtIndex(count - 1).title, "3-hash");
+    is(sh.getEntryAtIndex(count - 2).title, "2");
+    is(sh.getEntryAtIndex(count - 3).title, "1");
+    is(sh.getEntryAtIndex(count - 4).title, "Initial");
+  });
+});
diff --git a/docshell/test/browser/browser_ua_emulation.js b/docshell/test/browser/browser_ua_emulation.js
new file mode 100644
index 0000000000..f1e9657cd3
--- /dev/null
+++ b/docshell/test/browser/browser_ua_emulation.js
@@ -0,0 +1,71 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const URL = "data:text/html;charset=utf-8,<iframe id='test-iframe'></iframe>";
+
+// Test that the docShell UA emulation works
+async function contentTaskNoOverride() {
+  let docshell = docShell;
+  is(
+    docshell.browsingContext.customUserAgent,
+    "",
+    "There should initially be no customUserAgent"
+  );
+}
+
+async function contentTaskOverride() {
+  let docshell = docShell;
+  is(
+    docshell.browsingContext.customUserAgent,
+    "foo",
+    "The user agent should be changed to foo"
+  );
+
+  is(
+    content.navigator.userAgent,
+    "foo",
+    "The user agent should be changed to foo"
+  );
+
+  let frameWin = content.document.querySelector("#test-iframe").contentWindow;
+  is(
+    frameWin.navigator.userAgent,
+    "foo",
+    "The UA should be passed on to frames."
+  );
+
+  let newFrame = content.document.createElement("iframe");
+  content.document.body.appendChild(newFrame);
+
+  let newFrameWin = newFrame.contentWindow;
+  is(
+    newFrameWin.navigator.userAgent,
+    "foo",
+    "Newly created frames should use the new UA"
+  );
+
+  newFrameWin.location.reload();
+  await ContentTaskUtils.waitForEvent(newFrame, "load");
+
+  is(
+    newFrameWin.navigator.userAgent,
+    "foo",
+    "New UA should persist across reloads"
+  );
+}
+
+add_task(async function () {
+  await BrowserTestUtils.withNewTab(
+    { gBrowser, url: URL },
+    async function (browser) {
+      await SpecialPowers.spawn(browser, [], contentTaskNoOverride);
+
+      let browsingContext = BrowserTestUtils.getBrowsingContextFrom(browser);
+      browsingContext.customUserAgent = "foo";
+
+      await SpecialPowers.spawn(browser, [], contentTaskOverride);
+    }
+  );
+});
diff --git a/docshell/test/browser/browser_uriFixupAlternateRedirects.js b/docshell/test/browser/browser_uriFixupAlternateRedirects.js
new file mode 100644
index 0000000000..193e8cf489
--- /dev/null
+++ b/docshell/test/browser/browser_uriFixupAlternateRedirects.js
@@ -0,0 +1,66 @@
+"use strict";
+
+const { UrlbarTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/UrlbarTestUtils.sys.mjs"
+);
+
+const REDIRECTURL =
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  "http://www.example.com/browser/docshell/test/browser/redirect_to_example.sjs";
+
+add_task(async function () {
+  // Test both directly setting a value and pressing enter, or setting the
+  // value through input events, like the user would do.
+  const setValueFns = [
+    value => {
+      gURLBar.value = value;
+    },
+    value => {
+      return UrlbarTestUtils.promiseAutocompleteResultPopup({
+        window,
+        waitForFocus,
+        value,
+      });
+    },
+  ];
+  for (let setValueFn of setValueFns) {
+    let tab = await BrowserTestUtils.openNewForegroundTab(
+      gBrowser,
+      "about:blank"
+    );
+    // Enter search terms and start a search.
+    gURLBar.focus();
+    await setValueFn(REDIRECTURL);
+    let errorPageLoaded = BrowserTestUtils.waitForErrorPage(tab.linkedBrowser);
+    EventUtils.synthesizeKey("KEY_Enter");
+    await errorPageLoaded;
+    let [contentURL, originalURL] = await SpecialPowers.spawn(
+      tab.linkedBrowser,
+      [],
+      () => {
+        return [
+          content.document.documentURI,
+          content.document.mozDocumentURIIfNotForErrorPages.spec,
+        ];
+      }
+    );
+    info("Page that loaded: " + contentURL);
+    const errorURI = "about:neterror?";
+    ok(contentURL.startsWith(errorURI), "Should be on an error page");
+
+    const contentPrincipal = tab.linkedBrowser.contentPrincipal;
+    ok(
+      contentPrincipal.spec.startsWith(errorURI),
+      "Principal should be for the error page"
+    );
+
+    originalURL = new URL(originalURL);
+    is(
+      originalURL.host,
+      "example",
+      "Should be an error for http://example, not http://www.example.com/"
+    );
+
+    BrowserTestUtils.removeTab(tab);
+  }
+});
diff --git a/docshell/test/browser/browser_uriFixupIntegration.js b/docshell/test/browser/browser_uriFixupIntegration.js
new file mode 100644
index 0000000000..619fd9f61f
--- /dev/null
+++ b/docshell/test/browser/browser_uriFixupIntegration.js
@@ -0,0 +1,104 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { UrlbarTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/UrlbarTestUtils.sys.mjs"
+);
+const { SearchTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/SearchTestUtils.sys.mjs"
+);
+
+SearchTestUtils.init(this);
+
+const kSearchEngineID = "browser_urifixup_search_engine";
+const kSearchEngineURL = "https://example.com/?search={searchTerms}";
+const kPrivateSearchEngineID = "browser_urifixup_search_engine_private";
+const kPrivateSearchEngineURL = "https://example.com/?private={searchTerms}";
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.search.separatePrivateDefault.ui.enabled", true],
+      ["browser.search.separatePrivateDefault", true],
+    ],
+  });
+
+  // Add new fake search engines.
+  await SearchTestUtils.installSearchExtension(
+    {
+      name: kSearchEngineID,
+      search_url: "https://example.com/",
+      search_url_get_params: "search={searchTerms}",
+    },
+    { setAsDefault: true }
+  );
+
+  await SearchTestUtils.installSearchExtension(
+    {
+      name: kPrivateSearchEngineID,
+      search_url: "https://example.com/",
+      search_url_get_params: "private={searchTerms}",
+    },
+    { setAsDefaultPrivate: true }
+  );
+});
+
+add_task(async function test() {
+  // Test both directly setting a value and pressing enter, or setting the
+  // value through input events, like the user would do.
+  const setValueFns = [
+    (value, win) => {
+      win.gURLBar.value = value;
+    },
+    (value, win) => {
+      return UrlbarTestUtils.promiseAutocompleteResultPopup({
+        window: win,
+        waitForFocus: SimpleTest.waitForFocus,
+        value,
+      });
+    },
+  ];
+
+  for (let value of ["foo bar", "brokenprotocol:somethingelse"]) {
+    for (let setValueFn of setValueFns) {
+      for (let inPrivateWindow of [false, true]) {
+        await do_test(value, setValueFn, inPrivateWindow);
+      }
+    }
+  }
+});
+
+async function do_test(value, setValueFn, inPrivateWindow) {
+  info(`Search ${value} in a ${inPrivateWindow ? "private" : "normal"} window`);
+  let win = await BrowserTestUtils.openNewBrowserWindow({
+    private: inPrivateWindow,
+  });
+  // Enter search terms and start a search.
+  win.gURLBar.focus();
+  await setValueFn(value, win);
+
+  EventUtils.synthesizeKey("KEY_Enter", {}, win);
+
+  // Check that we load the correct URL.
+  let escapedValue = encodeURIComponent(value).replace("%20", "+");
+  let searchEngineUrl = inPrivateWindow
+    ? kPrivateSearchEngineURL
+    : kSearchEngineURL;
+  let expectedURL = searchEngineUrl.replace("{searchTerms}", escapedValue);
+  await BrowserTestUtils.browserLoaded(
+    win.gBrowser.selectedBrowser,
+    false,
+    expectedURL
+  );
+  // There should be at least one test.
+  Assert.equal(
+    win.gBrowser.selectedBrowser.currentURI.spec,
+    expectedURL,
+    "New tab should have loaded with expected url."
+  );
+
+  // Cleanup.
+  await BrowserTestUtils.closeWindow(win);
+}
diff --git a/docshell/test/browser/browser_viewsource_chrome_to_content.js b/docshell/test/browser/browser_viewsource_chrome_to_content.js
new file mode 100644
index 0000000000..933af2a4af
--- /dev/null
+++ b/docshell/test/browser/browser_viewsource_chrome_to_content.js
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "https://example.com"
+);
+const TEST_URI = `view-source:${TEST_PATH}dummy_page.html`;
+
+add_task(async function chrome_to_content_view_source() {
+  await BrowserTestUtils.withNewTab("about:mozilla", async browser => {
+    is(browser.documentURI.spec, "about:mozilla");
+
+    // This process switch would previously crash in debug builds due to assertion failures.
+    BrowserTestUtils.startLoadingURIString(browser, TEST_URI);
+    await BrowserTestUtils.browserLoaded(browser);
+    is(browser.documentURI.spec, TEST_URI);
+  });
+});
diff --git a/docshell/test/browser/browser_viewsource_multipart.js b/docshell/test/browser/browser_viewsource_multipart.js
new file mode 100644
index 0000000000..748cf4bce0
--- /dev/null
+++ b/docshell/test/browser/browser_viewsource_multipart.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+const TEST_PATH = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "https://example.com"
+);
+const MULTIPART_URI = `${TEST_PATH}file_basic_multipart.sjs`;
+
+add_task(async function viewsource_multipart_uri() {
+  await BrowserTestUtils.withNewTab("about:blank", async browser => {
+    BrowserTestUtils.startLoadingURIString(browser, MULTIPART_URI);
+    await BrowserTestUtils.browserLoaded(browser);
+    is(browser.currentURI.spec, MULTIPART_URI);
+
+    // Continue probing the URL until we find the h1 we're expecting. This
+    // should handle cases where we somehow beat the second document having
+    // loaded.
+    await TestUtils.waitForCondition(async () => {
+      let value = await SpecialPowers.spawn(browser, [], async () => {
+        let headers = content.document.querySelectorAll("h1");
+        is(headers.length, 1, "only one h1 should be present");
+        return headers[0].textContent;
+      });
+
+      ok(value == "First" || value == "Second", "some other value was found?");
+      return value == "Second";
+    });
+
+    // Load a view-source version of the page, which should show the full
+    // content, not handling multipart.
+    BrowserTestUtils.startLoadingURIString(
+      browser,
+      `view-source:${MULTIPART_URI}`
+    );
+    await BrowserTestUtils.browserLoaded(browser);
+
+    let viewSourceContent = await SpecialPowers.spawn(browser, [], async () => {
+      return content.document.body.textContent;
+    });
+
+    ok(viewSourceContent.includes("<h1>First</h1>"), "first header");
+    ok(viewSourceContent.includes("<h1>Second</h1>"), "second header");
+    ok(viewSourceContent.includes("BOUNDARY"), "boundary");
+  });
+});
diff --git a/docshell/test/browser/dummy_iframe_page.html b/docshell/test/browser/dummy_iframe_page.html
new file mode 100644
index 0000000000..12ce921856
--- /dev/null
+++ b/docshell/test/browser/dummy_iframe_page.html
@@ -0,0 +1,8 @@
+<html>
+<head> <meta charset="utf-8"> </head>
+  <body>
+    just a dummy html file with an iframe
+    <iframe id="frame1" src="dummy_page.html?sub_entry=0"></iframe>
+    <iframe id="frame2" src="dummy_page.html?sub_entry=0"></iframe>
+  </body>
+</html>
diff --git a/docshell/test/browser/dummy_page.html b/docshell/test/browser/dummy_page.html
new file mode 100644
index 0000000000..59bf2a5f8f
--- /dev/null
+++ b/docshell/test/browser/dummy_page.html
@@ -0,0 +1,6 @@
+<html>
+<head> <meta charset="utf-8"> </head>
+  <body>
+    just a dummy html file
+  </body>
+</html>
diff --git a/docshell/test/browser/favicon_bug655270.ico b/docshell/test/browser/favicon_bug655270.ico
new file mode 100644
index 0000000000..d44438903b
--- /dev/null
+++ b/docshell/test/browser/favicon_bug655270.ico
diff --git a/docshell/test/browser/file_backforward_restore_scroll.html b/docshell/test/browser/file_backforward_restore_scroll.html
new file mode 100644
index 0000000000..5a40b36c10
--- /dev/null
+++ b/docshell/test/browser/file_backforward_restore_scroll.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+</head>
+<body>
+  <iframe src="http://mochi.test:8888/"></iframe>
+  <iframe src="http://example.com/"></iframe>
+</body>
+</html>
diff --git a/docshell/test/browser/file_backforward_restore_scroll.html^headers^ b/docshell/test/browser/file_backforward_restore_scroll.html^headers^
new file mode 100644
index 0000000000..59ba296103
--- /dev/null
+++ b/docshell/test/browser/file_backforward_restore_scroll.html^headers^
@@ -0,0 +1 @@
+Cache-control: no-store
diff --git a/docshell/test/browser/file_basic_multipart.sjs b/docshell/test/browser/file_basic_multipart.sjs
new file mode 100644
index 0000000000..5e89b93948
--- /dev/null
+++ b/docshell/test/browser/file_basic_multipart.sjs
@@ -0,0 +1,24 @@
+"use strict";
+
+function handleRequest(request, response) {
+  response.setHeader(
+    "Content-Type",
+    "multipart/x-mixed-replace;boundary=BOUNDARY",
+    false
+  );
+  response.setStatusLine(request.httpVersion, 200, "OK");
+
+  response.write(`--BOUNDARY
+Content-Type: text/html
+
+<h1>First</h1>
+Will be replaced
+--BOUNDARY
+Content-Type: text/html
+
+<h1>Second</h1>
+This will stick around
+--BOUNDARY
+--BOUNDARY--
+`);
+}
diff --git a/docshell/test/browser/file_bug1046022.html b/docshell/test/browser/file_bug1046022.html
new file mode 100644
index 0000000000..27a1e1f079
--- /dev/null
+++ b/docshell/test/browser/file_bug1046022.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Bug 1046022 - test navigating inside onbeforeunload</title>
+  </head>
+  <body>
+    Waiting for onbeforeunload to hit...
+  </body>
+
+  <script>
+var testFns = [
+  function(e) {
+    e.target.location.href = "otherpage-href-set.html";
+    return "stop";
+  },
+  function(e) {
+    e.target.location.reload();
+    return "stop";
+  },
+  function(e) {
+    e.currentTarget.stop();
+    return "stop";
+  },
+  function(e) {
+    e.target.location.replace("otherpage-location-replaced.html");
+    return "stop";
+  },
+  function(e) {
+    var link = e.target.createElement("a");
+    link.href = "otherpage.html";
+    e.target.body.appendChild(link);
+    link.click();
+    return "stop";
+  },
+  function(e) {
+    var link = e.target.createElement("a");
+    link.href = "otherpage.html";
+    link.setAttribute("target", "_blank");
+    e.target.body.appendChild(link);
+    link.click();
+    return "stop";
+  },
+  function(e) {
+    var link = e.target.createElement("a");
+    link.href = e.target.location.href;
+    e.target.body.appendChild(link);
+    link.setAttribute("target", "somearbitrarywindow");
+    link.click();
+    return "stop";
+  },
+];
+  </script>
+</html>
diff --git a/docshell/test/browser/file_bug1206879.html b/docshell/test/browser/file_bug1206879.html
new file mode 100644
index 0000000000..5313902a9b
--- /dev/null
+++ b/docshell/test/browser/file_bug1206879.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Test page for bug 1206879</title>
+  </head>
+  <body>
+    <iframe src="http://example.com/"></iframe>
+  </body>
+</html>
diff --git a/docshell/test/browser/file_bug1328501.html b/docshell/test/browser/file_bug1328501.html
new file mode 100644
index 0000000000..517ef53e02
--- /dev/null
+++ b/docshell/test/browser/file_bug1328501.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>Page with iframes</title>
+    <script type="application/javascript">
+    let promiseResolvers = {
+      "testFrame1": {},
+      "testFrame2": {},
+    };
+    let promises = [
+      new Promise(r => promiseResolvers.testFrame1.resolve = r),
+      new Promise(r => promiseResolvers.testFrame2.resolve = r),
+    ];
+    function frameLoaded(frame) {
+      promiseResolvers[frame].resolve();
+    }
+    Promise.all(promises).then(() => window.dispatchEvent(new Event("frames-loaded")));
+    </script>
+  </head>
+  <body onunload="">
+    <div>
+      <iframe id="testFrame1" src="dummy_page.html" onload="frameLoaded(this.id);" ></iframe>
+      <iframe id="testFrame2" src="dummy_page.html" onload="frameLoaded(this.id);" ></iframe>
+    </div>
+  </body>
+</html>
diff --git a/docshell/test/browser/file_bug1328501_frame.html b/docshell/test/browser/file_bug1328501_frame.html
new file mode 100644
index 0000000000..156dd41eaa
--- /dev/null
+++ b/docshell/test/browser/file_bug1328501_frame.html
@@ -0,0 +1,4 @@
+<!DOCTYPE html>
+<html lang="en">
+  <body>Subframe page for testing</body>
+</html>
diff --git a/docshell/test/browser/file_bug1328501_framescript.js b/docshell/test/browser/file_bug1328501_framescript.js
new file mode 100644
index 0000000000..19c86c75e7
--- /dev/null
+++ b/docshell/test/browser/file_bug1328501_framescript.js
@@ -0,0 +1,38 @@
+// Forward iframe loaded event.
+
+/* eslint-env mozilla/frame-script */
+
+addEventListener(
+  "frames-loaded",
+  e => sendAsyncMessage("test:frames-loaded"),
+  true,
+  true
+);
+
+let requestObserver = {
+  observe(subject, topic, data) {
+    if (topic == "http-on-opening-request") {
+      // Get DOMWindow on all child docshells to force about:blank
+      // content viewers being created.
+      getChildDocShells().map(ds => {
+        ds
+          .QueryInterface(Ci.nsIInterfaceRequestor)
+          .getInterface(Ci.nsILoadContext).associatedWindow;
+      });
+    }
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsIObserver"]),
+};
+Services.obs.addObserver(requestObserver, "http-on-opening-request");
+addEventListener("unload", e => {
+  if (e.target == this) {
+    Services.obs.removeObserver(requestObserver, "http-on-opening-request");
+  }
+});
+
+function getChildDocShells() {
+  return docShell.getAllDocShellsInSubtree(
+    Ci.nsIDocShellTreeItem.typeAll,
+    Ci.nsIDocShell.ENUMERATE_FORWARDS
+  );
+}
diff --git a/docshell/test/browser/file_bug1543077-3-child.html b/docshell/test/browser/file_bug1543077-3-child.html
new file mode 100644
index 0000000000..858a4623ed
--- /dev/null
+++ b/docshell/test/browser/file_bug1543077-3-child.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<p>Hiragana letter a if decoded as ISO-2022-JP: $B$"(B</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug1543077-3.html b/docshell/test/browser/file_bug1543077-3.html
new file mode 100644
index 0000000000..c4f467dd3f
--- /dev/null
+++ b/docshell/test/browser/file_bug1543077-3.html
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<h1>No encoding declaration in parent or child</h1>
+
+<p>Hiragana letter a if decoded as ISO-2022-JP: $B$"(B</p>
+
+<iframe src="file_bug1543077-3-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug1622420.html b/docshell/test/browser/file_bug1622420.html
new file mode 100644
index 0000000000..63beb38302
--- /dev/null
+++ b/docshell/test/browser/file_bug1622420.html
@@ -0,0 +1 @@
+<iframe src="http://example.com/"></iframe>
diff --git a/docshell/test/browser/file_bug1648464-1-child.html b/docshell/test/browser/file_bug1648464-1-child.html
new file mode 100644
index 0000000000..7bb1ad965b
--- /dev/null
+++ b/docshell/test/browser/file_bug1648464-1-child.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset=windows-1252>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>windows-1252 in parent and child, actually EUC-JP</title>
+</head>
+<body>
+<p>Hiragana letter a if decoded as EUC-JP: €’</p>
+<p>€³€μ€ΟΚΈ»ϊΌΒΈ³€Η€Ή‘£</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug1648464-1.html b/docshell/test/browser/file_bug1648464-1.html
new file mode 100644
index 0000000000..2051cf61ed
--- /dev/null
+++ b/docshell/test/browser/file_bug1648464-1.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset=windows-1252>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>windows-1252 in parent and child, actually EUC-JP</title>
+</head>
+<body>
+<h1>windows-1252 in parent and child, actually EUC-JP</h1>
+
+<p>Hiragana letter a if decoded as EUC-JP: €’</p>
+<p>€³€μ€ΟΚΈ»ϊΌΒΈ³€Η€Ή‘£</p>
+
+<iframe src="file_bug1648464-1-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug1673702.json b/docshell/test/browser/file_bug1673702.json
new file mode 100644
index 0000000000..3f562dd675
--- /dev/null
+++ b/docshell/test/browser/file_bug1673702.json
@@ -0,0 +1 @@
+{ "version": 1 }
diff --git a/docshell/test/browser/file_bug1673702.json^headers^ b/docshell/test/browser/file_bug1673702.json^headers^
new file mode 100644
index 0000000000..6010bfd188
--- /dev/null
+++ b/docshell/test/browser/file_bug1673702.json^headers^
@@ -0,0 +1 @@
+Content-Type: application/json; charset=utf-8
diff --git a/docshell/test/browser/file_bug1688368-1.sjs b/docshell/test/browser/file_bug1688368-1.sjs
new file mode 100644
index 0000000000..0693b7970c
--- /dev/null
+++ b/docshell/test/browser/file_bug1688368-1.sjs
@@ -0,0 +1,44 @@
+"use strict";
+
+const DELAY = 1 * 1000; // Delay one second before completing the request.
+
+let nsTimer = Components.Constructor(
+  "@mozilla.org/timer;1",
+  "nsITimer",
+  "initWithCallback"
+);
+
+let timer;
+
+function handleRequest(request, response) {
+  response.processAsync();
+
+  response.setHeader("Content-Type", "text/html", false);
+  response.setHeader("Cache-Control", "no-cache", false);
+  response.write(`<!DOCTYPE html>
+<html>
+<head>
+	<title>UTF-8 file, 1024 bytes long!</title>
+</head>
+<body>`);
+
+  // Note: We need to store a reference to the timer to prevent it from being
+  // canceled when it's GCed.
+  timer = new nsTimer(
+    () => {
+      var snowmen =
+        "\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083\u00E2\u0098\u0083";
+      response.write(
+        snowmen +
+          `
+</body>
+</html>
+
+`
+      );
+      response.finish();
+    },
+    DELAY,
+    Ci.nsITimer.TYPE_ONE_SHOT
+  );
+}
diff --git a/docshell/test/browser/file_bug1691153.html b/docshell/test/browser/file_bug1691153.html
new file mode 100644
index 0000000000..dea144eb41
--- /dev/null
+++ b/docshell/test/browser/file_bug1691153.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>bug 1691153</title>
+</head>
+<body>
+<h1>bug 1691153</h1>
+<script>
+function toBlobURL(data, mimeType) {
+  return URL.createObjectURL(
+    new Blob([data], {
+      type: mimeType,
+    })
+  );
+}
+// closing script element literal split up to not end the parent script element
+let testurl = toBlobURL("<body></body>", "text/html");
+addEventListener("message", event => {
+  if (event.data == "getblob") {
+    postMessage({ bloburl: testurl }, "*");
+  }
+});
+// the blob URL should have a content principal
+</script>
+</body>
+</html>
diff --git a/docshell/test/browser/file_bug1716290-1.sjs b/docshell/test/browser/file_bug1716290-1.sjs
new file mode 100644
index 0000000000..83e6eede3d
--- /dev/null
+++ b/docshell/test/browser/file_bug1716290-1.sjs
@@ -0,0 +1,21 @@
+function handleRequest(request, response) {
+  if (getState("reloaded") == "reloaded") {
+    response.setHeader(
+      "Content-Type",
+      "text/html; charset=windows-1254",
+      false
+    );
+    response.write("\u00E4");
+  } else {
+    response.setHeader("Content-Type", "text/html; charset=Shift_JIS", false);
+    if (getState("loaded") == "loaded") {
+      setState("reloaded", "reloaded");
+    } else {
+      setState("loaded", "loaded");
+    }
+    // kilobyte to force late-detection reload
+    response.write("a".repeat(1024));
+    response.write("<body>");
+    response.write("\u00E4");
+  }
+}
diff --git a/docshell/test/browser/file_bug1716290-2.sjs b/docshell/test/browser/file_bug1716290-2.sjs
new file mode 100644
index 0000000000..e695259e30
--- /dev/null
+++ b/docshell/test/browser/file_bug1716290-2.sjs
@@ -0,0 +1,18 @@
+function handleRequest(request, response) {
+  if (getState("reloaded") == "reloaded") {
+    response.setHeader("Content-Type", "text/html", false);
+    response.write("<meta charset=iso-2022-kr>\u00E4");
+  } else {
+    response.setHeader("Content-Type", "text/html", false);
+    if (getState("loaded") == "loaded") {
+      setState("reloaded", "reloaded");
+    } else {
+      setState("loaded", "loaded");
+    }
+    response.write("<meta charset=Shift_JIS>");
+    // kilobyte to force late-detection reload
+    response.write("a".repeat(1024));
+    response.write("<body>");
+    response.write("\u00E4");
+  }
+}
diff --git a/docshell/test/browser/file_bug1716290-3.sjs b/docshell/test/browser/file_bug1716290-3.sjs
new file mode 100644
index 0000000000..7a302e05e4
--- /dev/null
+++ b/docshell/test/browser/file_bug1716290-3.sjs
@@ -0,0 +1,17 @@
+function handleRequest(request, response) {
+  if (getState("reloaded") == "reloaded") {
+    response.setHeader("Content-Type", "text/html; charset=iso-2022-kr", false);
+    response.write("\u00E4");
+  } else {
+    response.setHeader("Content-Type", "text/html; charset=Shift_JIS", false);
+    if (getState("loaded") == "loaded") {
+      setState("reloaded", "reloaded");
+    } else {
+      setState("loaded", "loaded");
+    }
+    // kilobyte to force late-detection reload
+    response.write("a".repeat(1024));
+    response.write("<body>");
+    response.write("\u00E4");
+  }
+}
diff --git a/docshell/test/browser/file_bug1716290-4.sjs b/docshell/test/browser/file_bug1716290-4.sjs
new file mode 100644
index 0000000000..36753ef532
--- /dev/null
+++ b/docshell/test/browser/file_bug1716290-4.sjs
@@ -0,0 +1,17 @@
+function handleRequest(request, response) {
+  if (getState("reloaded") == "reloaded") {
+    response.setHeader("Content-Type", "text/html", false);
+    response.write("\u00FE\u00FF\u00E4");
+  } else {
+    response.setHeader("Content-Type", "text/html; charset=Shift_JIS", false);
+    if (getState("loaded") == "loaded") {
+      setState("reloaded", "reloaded");
+    } else {
+      setState("loaded", "loaded");
+    }
+    // kilobyte to force late-detection reload
+    response.write("a".repeat(1024));
+    response.write("<body>");
+    response.write("\u00E4");
+  }
+}
diff --git a/docshell/test/browser/file_bug1736248-1.html b/docshell/test/browser/file_bug1736248-1.html
new file mode 100644
index 0000000000..177acb8f77
--- /dev/null
+++ b/docshell/test/browser/file_bug1736248-1.html
@@ -0,0 +1,4 @@
+Kilobyte of ASCII followed by UTF-8.
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+
+Hej vΓ€rlden!
diff --git a/docshell/test/browser/file_bug234628-1-child.html b/docshell/test/browser/file_bug234628-1-child.html
new file mode 100644
index 0000000000..c36197ac4f
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-1-child.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-1.html b/docshell/test/browser/file_bug234628-1.html
new file mode 100644
index 0000000000..11c523ccd9
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-1.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<h1>No encoding declaration in parent or child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-1-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-10-child.xhtml b/docshell/test/browser/file_bug234628-10-child.xhtml
new file mode 100644
index 0000000000..cccf6f2bc0
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-10-child.xhtml
@@ -0,0 +1,4 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head><title>XML child with no encoding declaration</title></head>
+<body><p>Euro sign if decoded as UTF-8: €</p></body>
+</html>
diff --git a/docshell/test/browser/file_bug234628-10.html b/docshell/test/browser/file_bug234628-10.html
new file mode 100644
index 0000000000..78b8f0035d
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-10.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in HTML parent or XHTML child</title>
+</head>
+<body>
+<h1>No encoding declaration in HTML parent or XHTML child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-10-child.xhtml"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-11-child.xhtml b/docshell/test/browser/file_bug234628-11-child.xhtml
new file mode 100644
index 0000000000..11ef668b0c
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-11-child.xhtml
@@ -0,0 +1,4 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head><title>No encoding declaration in HTML parent and HTTP declaration in XHTML child</title></head>
+<body><p>Euro sign if decoded as UTF-8: €</p></body>
+</html>
diff --git a/docshell/test/browser/file_bug234628-11-child.xhtml^headers^ b/docshell/test/browser/file_bug234628-11-child.xhtml^headers^
new file mode 100644
index 0000000000..30fb304056
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-11-child.xhtml^headers^
@@ -0,0 +1 @@
+Content-Type: application/xhtml+xml; charset=utf-8
diff --git a/docshell/test/browser/file_bug234628-11.html b/docshell/test/browser/file_bug234628-11.html
new file mode 100644
index 0000000000..21c5b733e0
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-11.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in HTML parent and HTTP declaration in XHTML child</title>
+</head>
+<body>
+<h1>No encoding declaration in HTML parent and HTTP declaration in XHTML child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-11-child.xhtml"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-2-child.html b/docshell/test/browser/file_bug234628-2-child.html
new file mode 100644
index 0000000000..0acd2e0b27
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-2-child.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<p>Euro sign if decoded as UTF-8: €</p>
+<p>a with diaeresis if decoded as UTF-8: Γ€</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-2.html b/docshell/test/browser/file_bug234628-2.html
new file mode 100644
index 0000000000..a87d29e126
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-2.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>No encoding declaration in parent or child</title>
+</head>
+<body>
+<h1>No encoding declaration in parent or child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-2-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-3-child.html b/docshell/test/browser/file_bug234628-3-child.html
new file mode 100644
index 0000000000..a6ad832310
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-3-child.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and child</title>
+</head>
+<body>
+<p>Euro sign if decoded as UTF-8: €</p>
+<p>a with diaeresis if decoded as UTF-8: Γ€</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-3.html b/docshell/test/browser/file_bug234628-3.html
new file mode 100644
index 0000000000..8caab60402
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-3.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="windows-1252">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and child</title>
+</head>
+<body>
+<h1>meta declaration in parent and child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-3-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-4-child.html b/docshell/test/browser/file_bug234628-4-child.html
new file mode 100644
index 0000000000..f0e7c2c058
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-4-child.html
@@ -0,0 +1,12 @@
+ο»Ώ<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and BOM in child</title>
+</head>
+<body>
+<p>Euro sign if decoded as UTF-8: €</p>
+<p>a with diaeresis if decoded as UTF-8: Γ€</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-4.html b/docshell/test/browser/file_bug234628-4.html
new file mode 100644
index 0000000000..0137579010
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-4.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="windows-1252">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and BOM in child</title>
+</head>
+<body>
+<h1>meta declaration in parent and BOM in child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-4-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-5-child.html b/docshell/test/browser/file_bug234628-5-child.html
new file mode 100644
index 0000000000..a650552f63
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-5-child.html
diff --git a/docshell/test/browser/file_bug234628-5.html b/docshell/test/browser/file_bug234628-5.html
new file mode 100644
index 0000000000..987e6420be
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-5.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="windows-1252">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and UTF-16 BOM in child</title>
+</head>
+<body>
+<h1>meta declaration in parent and UTF-16 BOM in child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-5-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-6-child.html b/docshell/test/browser/file_bug234628-6-child.html
new file mode 100644
index 0000000000..52c37f2596
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-6-child.html
diff --git a/docshell/test/browser/file_bug234628-6-child.html^headers^ b/docshell/test/browser/file_bug234628-6-child.html^headers^
new file mode 100644
index 0000000000..bfdcf487fb
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-6-child.html^headers^
@@ -0,0 +1 @@
+Content-Type: text/html; charset=utf-16be
diff --git a/docshell/test/browser/file_bug234628-6.html b/docshell/test/browser/file_bug234628-6.html
new file mode 100644
index 0000000000..9d7fc580c3
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-6.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="windows-1252">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and BOMless UTF-16 with HTTP charset in child</title>
+</head>
+<body>
+<h1>meta declaration in parent and BOMless UTF-16 with HTTP charset in child</h1>
+
+<p>Euro sign if decoded as Windows-1252: €</p>
+<p>a with diaeresis if decoded as Windows-1252: δ</p>
+
+<iframe src="file_bug234628-6-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-8-child.html b/docshell/test/browser/file_bug234628-8-child.html
new file mode 100644
index 0000000000..254e0fb2b3
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-8-child.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and no declaration in child</title>
+</head>
+<body>
+<p>Capital dje if decoded as Windows-1251: €</p>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-8.html b/docshell/test/browser/file_bug234628-8.html
new file mode 100644
index 0000000000..b44e91801c
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-8.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="windows-1251">
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>meta declaration in parent and no declaration in child</title>
+</head>
+<body>
+<h1>meta declaration in parent and no declaration in child</h1>
+
+<p>Capital dje if decoded as Windows-1251: €</p>
+
+<iframe src="file_bug234628-8-child.html"></iframe>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-9-child.html b/docshell/test/browser/file_bug234628-9-child.html
new file mode 100644
index 0000000000..a86b14d7ee
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-9-child.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>UTF-16 with BOM in parent and no declaration in child</title>
+</head>
+<body>
+<p>Euro sign if decoded as Windows-1251: €</p>
+
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug234628-9.html b/docshell/test/browser/file_bug234628-9.html
new file mode 100644
index 0000000000..8a469da3aa
--- /dev/null
+++ b/docshell/test/browser/file_bug234628-9.html
diff --git a/docshell/test/browser/file_bug420605.html b/docshell/test/browser/file_bug420605.html
new file mode 100644
index 0000000000..8424b92f8f
--- /dev/null
+++ b/docshell/test/browser/file_bug420605.html
@@ -0,0 +1,31 @@
+<head>
+<link rel="icon" type="image/png" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAHWSURBVHjaYvz//z8DJQAggJiQOe/fv2fv7Oz8rays/N+VkfG/iYnJfyD/1+rVq7ffu3dPFpsBAAHEAHIBCJ85c8bN2Nj4vwsDw/8zQLwKiO8CcRoQu0DxqlWrdsHUwzBAAIGJmTNnPgYa9j8UqhFElwPxf2MIDeIrKSn9FwSJoRkAEEAM0DD4DzMAyPi/G+QKY4hh5WAXGf8PDQ0FGwJ22d27CjADAAIIrLmjo+MXA9R2kAHvGBA2wwx6B8W7od6CeQcggKCmCEL8bgwxYCbUIGTDVkHDBia+CuotgACCueD3TDQN75D4xmAvCoK9ARMHBzAw0AECiBHkAlC0Mdy7x9ABNA3obAZXIAa6iKEcGlMVQHwWyjYuL2d4v2cPg8vZswx7gHyAAAK7AOif7SAbOqCmn4Ha3AHFsIDtgPq/vLz8P4MSkJ2W9h8ggBjevXvHDo4FQUQg/kdypqCg4H8lUIACnQ/SOBMYI8bAsAJFPcj1AAEEjwVQqLpAbXmH5BJjqI0gi9DTAAgDBBCcAVLkgmQ7yKCZxpCQxqUZhAECCJ4XgMl493ug21ZD+aDAXH0WLM4A9MZPXJkJIIAwTAR5pQMalaCABQUULttBGCCAGCnNzgABBgAMJ5THwGvJLAAAAABJRU5ErkJggg=="/>
+  <title>Page Title for Bug 420605</title>
+</head>
+<body>
+  <h1>Fragment links</h1>
+
+  <p>This page has a bunch of fragment links to sections below:</p>
+
+  <ul>
+    <li><a id="firefox-link" href="#firefox">Firefox</a></li>
+    <li><a id="thunderbird-link" href="#thunderbird">Thunderbird</a></li>
+    <li><a id="seamonkey-link" href="#seamonkey">Seamonkey</a></li>
+  </ul>
+
+  <p>And here are the sections:</p>
+
+  <h2 id="firefox">Firefox</h2>
+
+  <p>Firefox is a browser.</p>
+
+  <h2 id="thunderbird">Thunderbird</h2>
+
+  <p>Thunderbird is an email client</p>
+
+  <h2 id="seamonkey">Seamonkey</h2>
+
+  <p>Seamonkey is the all-in-one application.</p>
+
+</body>
+</html>
diff --git a/docshell/test/browser/file_bug503832.html b/docshell/test/browser/file_bug503832.html
new file mode 100644
index 0000000000..338631c8a0
--- /dev/null
+++ b/docshell/test/browser/file_bug503832.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+<!--
+Test page for https://bugzilla.mozilla.org/show_bug.cgi?id=503832
+-->
+<head>
+  <title>Page Title for Bug 503832</title>
+</head>
+<body>
+  <h1>Fragment links</h1>
+
+  <p>This page has a bunch of fragment links to sections below:</p>
+
+  <ul>
+    <li><a id="firefox-link" href="#firefox">Firefox</a></li>
+    <li><a id="thunderbird-link" href="#thunderbird">Thunderbird</a></li>
+    <li><a id="seamonkey-link" href="#seamonkey">Seamonkey</a></li>
+  </ul>
+
+  <p>And here are the sections:</p>
+
+  <h2 id="firefox">Firefox</h2>
+
+  <p>Firefox is a browser.</p>
+
+  <h2 id="thunderbird">Thunderbird</h2>
+
+  <p>Thunderbird is an email client</p>
+
+  <h2 id="seamonkey">Seamonkey</h2>
+
+  <p>Seamonkey is the all-in-one application.</p>
+
+</body>
+</html>
diff --git a/docshell/test/browser/file_bug655270.html b/docshell/test/browser/file_bug655270.html
new file mode 100644
index 0000000000..0c08d982b1
--- /dev/null
+++ b/docshell/test/browser/file_bug655270.html
@@ -0,0 +1,11 @@
+<html>
+
+<head>
+  <link rel='icon' href='favicon_bug655270.ico'>
+</head>
+
+<body>
+Nothing to see here...
+</body>
+
+</html>
diff --git a/docshell/test/browser/file_bug670318.html b/docshell/test/browser/file_bug670318.html
new file mode 100644
index 0000000000..a78e8fcb19
--- /dev/null
+++ b/docshell/test/browser/file_bug670318.html
@@ -0,0 +1,23 @@
+<html><head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<script>
+function load() {
+  function next() {
+    if (count < 5)
+      iframe.src = "data:text/html;charset=utf-8,iframe " + (++count);
+  }
+
+  var count = 0;
+  var iframe = document.createElement("iframe");
+  iframe.onload = function() { setTimeout(next, 0); };
+  document.body.appendChild(iframe);
+
+  setTimeout(next, 0);
+}
+</script>
+</head>
+
+<body onload="load()">
+Testcase
+</body>
+</html>
diff --git a/docshell/test/browser/file_bug673087-1-child.html b/docshell/test/browser/file_bug673087-1-child.html
new file mode 100644
index 0000000000..7bb1ad965b
--- /dev/null
+++ b/docshell/test/browser/file_bug673087-1-child.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset=windows-1252>
+<meta content="width=device-width, initial-scale=1" name="viewport">
+<title>windows-1252 in parent and child, actually EUC-JP</title>
+</head>
+<body>
+<p>Hiragana letter a if decoded as EUC-JP: €’</p>
+<p>€³€μ€ΟΚΈ»ϊΌΒΈ³€Η€Ή‘£</p>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_bug673087-1.html b/docshell/test/browser/file_bug673087-1.html
new file mode 100644
index 0000000000..3dbea43d66
--- /dev/null
+++ b/docshell/test/browser/file_bug673087-1.html
diff --git a/docshell/test/browser/file_bug673087-1.html^headers^ b/docshell/test/browser/file_bug673087-1.html^headers^
new file mode 100644
index 0000000000..2340a89c93
--- /dev/null
+++ b/docshell/test/browser/file_bug673087-1.html^headers^
@@ -0,0 +1 @@
+Content-Type: text/html; charset=windows-1252
diff --git a/docshell/test/browser/file_bug673087-2.html b/docshell/test/browser/file_bug673087-2.html
new file mode 100644
index 0000000000..ccbf896ca6
--- /dev/null
+++ b/docshell/test/browser/file_bug673087-2.html
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="ISO-2022-KR">
+FAIL
\ No newline at end of file
diff --git a/docshell/test/browser/file_bug852909.pdf b/docshell/test/browser/file_bug852909.pdf
new file mode 100644
index 0000000000..89066463f1
--- /dev/null
+++ b/docshell/test/browser/file_bug852909.pdf
diff --git a/docshell/test/browser/file_bug852909.png b/docshell/test/browser/file_bug852909.png
new file mode 100644
index 0000000000..c7510d388f
--- /dev/null
+++ b/docshell/test/browser/file_bug852909.png
diff --git a/docshell/test/browser/file_click_link_within_view_source.html b/docshell/test/browser/file_click_link_within_view_source.html
new file mode 100644
index 0000000000..d78e4ba0ff
--- /dev/null
+++ b/docshell/test/browser/file_click_link_within_view_source.html
@@ -0,0 +1,6 @@
+<html>
+<head> <meta charset="utf-8"> </head>
+  <body>
+  <a id="testlink" href="dummy_page.html">clickme</a>
+  </body>
+</html>
diff --git a/docshell/test/browser/file_cross_process_csp_inheritance.html b/docshell/test/browser/file_cross_process_csp_inheritance.html
new file mode 100644
index 0000000000..d87761a609
--- /dev/null
+++ b/docshell/test/browser/file_cross_process_csp_inheritance.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="UTF-8">
+ <title>Test CSP inheritance if load happens in same and different process</title>
+ <meta http-equiv="Content-Security-Policy" content="script-src 'none'">
+</head>
+<body>
+  <a href="data:text/html,<html>test-same-diff-process-csp-inhertiance</html>" id="testLink" target="_blank" rel="noopener">click to test same/diff process CSP inheritance</a>
+</body>
+</html>
diff --git a/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html b/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html
new file mode 100644
index 0000000000..49341f7481
--- /dev/null
+++ b/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Test Javascript URI with no script</title>
+</head>
+<body>
+<noscript>no scripts allowed here</noscript>
+<a href="javascript:alert(`origin=${origin} location=${location}`)" target="_parent">click me</a>
+</body>
+</html>
diff --git a/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html^headers^ b/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html^headers^
new file mode 100644
index 0000000000..461f7f99ce
--- /dev/null
+++ b/docshell/test/browser/file_csp_sandbox_no_script_js_uri.html^headers^
@@ -0,0 +1 @@
+Content-Security-Policy: sandbox allow-same-origin allow-top-navigation;
diff --git a/docshell/test/browser/file_csp_uir.html b/docshell/test/browser/file_csp_uir.html
new file mode 100644
index 0000000000..be60f41a80
--- /dev/null
+++ b/docshell/test/browser/file_csp_uir.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Bug 1542858 - Test CSP upgrade-insecure-requests</title>
+  <meta http-equiv="Content-Security-Policy" content="upgrade-insecure-requests">
+</head>
+<body>
+  <a id="testlink" href="file_csp_uir_dummy.html">testlink</a>
+</body>
+</html>
diff --git a/docshell/test/browser/file_csp_uir_dummy.html b/docshell/test/browser/file_csp_uir_dummy.html
new file mode 100644
index 0000000000..f0ab6775c0
--- /dev/null
+++ b/docshell/test/browser/file_csp_uir_dummy.html
@@ -0,0 +1 @@
+<html><body>foo</body></html>
diff --git a/docshell/test/browser/file_data_load_inherit_csp.html b/docshell/test/browser/file_data_load_inherit_csp.html
new file mode 100644
index 0000000000..1efe738e4c
--- /dev/null
+++ b/docshell/test/browser/file_data_load_inherit_csp.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Bug 1358009 - Inherit CSP into data URI</title>
+  <meta http-equiv="Content-Security-Policy" content="script-src 'unsafe-inline'">
+</head>
+<body>
+  <a id="testlink">testlink</a>
+</body>
+</html>
diff --git a/docshell/test/browser/file_multiple_pushState.html b/docshell/test/browser/file_multiple_pushState.html
new file mode 100644
index 0000000000..6592f3f53f
--- /dev/null
+++ b/docshell/test/browser/file_multiple_pushState.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Test multiple calls to history.pushState</title>
+  </head>
+  <body>
+    <h1>Ohai</h1>
+  </body>
+  <script type="text/javascript">
+    window.history.pushState({}, "", "/bar/ABC?key=baz");
+    let data = new Array(100000).join("a");
+    window.history.pushState({ data }, "", "/bar/ABC/DEF?key=baz");
+    // Test also Gecko specific state object size limit.
+    try {
+      let largeData = new Array(20000000).join("a");
+      window.history.pushState({ largeData }, "", "/bar/ABC/DEF/GHI?key=baz");
+    } catch (ex) {}
+  </script>
+</html>
diff --git a/docshell/test/browser/file_onbeforeunload_0.html b/docshell/test/browser/file_onbeforeunload_0.html
new file mode 100644
index 0000000000..7d9acf057d
--- /dev/null
+++ b/docshell/test/browser/file_onbeforeunload_0.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+</head>
+<body>
+  <iframe src="http://example.com/browser/docshell/test/browser/file_onbeforeunload_1.html"></iframe>
+</body>
+</html>
diff --git a/docshell/test/browser/file_onbeforeunload_1.html b/docshell/test/browser/file_onbeforeunload_1.html
new file mode 100644
index 0000000000..edd27783e4
--- /dev/null
+++ b/docshell/test/browser/file_onbeforeunload_1.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+</head>
+<body>
+  <iframe src="http://mochi.test:8888/browser/docshell/test/browser/file_onbeforeunload_2.html"></iframe>
+</body>
+</html>
diff --git a/docshell/test/browser/file_onbeforeunload_2.html b/docshell/test/browser/file_onbeforeunload_2.html
new file mode 100644
index 0000000000..a52a4ace5c
--- /dev/null
+++ b/docshell/test/browser/file_onbeforeunload_2.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+</head>
+<body>
+  <iframe src="http://example.com/browser/docshell/test/browser/file_onbeforeunload_3.html"></iframe>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_onbeforeunload_3.html b/docshell/test/browser/file_onbeforeunload_3.html
new file mode 100644
index 0000000000..9914f0cd85
--- /dev/null
+++ b/docshell/test/browser/file_onbeforeunload_3.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+</head>
+<body>
+</body>
+</html>
+
diff --git a/docshell/test/browser/file_open_about_blank.html b/docshell/test/browser/file_open_about_blank.html
new file mode 100644
index 0000000000..134384e2f7
--- /dev/null
+++ b/docshell/test/browser/file_open_about_blank.html
@@ -0,0 +1,2 @@
+<!doctype html>
+<button id="open" onclick="window.open('')">Open child window</button>
diff --git a/docshell/test/browser/file_slow_load.sjs b/docshell/test/browser/file_slow_load.sjs
new file mode 100644
index 0000000000..4c6dd6d5b9
--- /dev/null
+++ b/docshell/test/browser/file_slow_load.sjs
@@ -0,0 +1,8 @@
+"use strict";
+
+function handleRequest(request, response) {
+  response.processAsync();
+  response.setHeader("Content-Type", "text/html");
+  response.write("<!doctype html>Loading... ");
+  // We don't block on this, so it's fine to never finish the response.
+}
diff --git a/docshell/test/browser/head.js b/docshell/test/browser/head.js
new file mode 100644
index 0000000000..38f2528a2f
--- /dev/null
+++ b/docshell/test/browser/head.js
@@ -0,0 +1,197 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Helper function for encoding override tests, loads URL, runs check1,
+ * forces encoding detection, runs check2.
+ */
+function runCharsetTest(url, check1, check2) {
+  waitForExplicitFinish();
+
+  BrowserTestUtils.openNewForegroundTab(gBrowser, url, true).then(afterOpen);
+
+  function afterOpen() {
+    BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(
+      afterChangeCharset
+    );
+
+    SpecialPowers.spawn(gBrowser.selectedBrowser, [], check1).then(() => {
+      BrowserForceEncodingDetection();
+    });
+  }
+
+  function afterChangeCharset() {
+    SpecialPowers.spawn(gBrowser.selectedBrowser, [], check2).then(() => {
+      gBrowser.removeCurrentTab();
+      finish();
+    });
+  }
+}
+
+/**
+ * Helper function for charset tests. It loads |url| in a new tab,
+ * runs |check|.
+ */
+function runCharsetCheck(url, check) {
+  waitForExplicitFinish();
+
+  BrowserTestUtils.openNewForegroundTab(gBrowser, url, true).then(afterOpen);
+
+  function afterOpen() {
+    SpecialPowers.spawn(gBrowser.selectedBrowser, [], check).then(() => {
+      gBrowser.removeCurrentTab();
+      finish();
+    });
+  }
+}
+
+async function pushState(url, frameId) {
+  info(
+    `Doing a pushState, expecting to load ${url} ${
+      frameId ? "in an iframe" : ""
+    }`
+  );
+  let browser = gBrowser.selectedBrowser;
+  let bc = browser.browsingContext;
+  if (frameId) {
+    bc = await SpecialPowers.spawn(bc, [frameId], function (id) {
+      return content.document.getElementById(id).browsingContext;
+    });
+  }
+  let loaded = BrowserTestUtils.waitForLocationChange(gBrowser, url);
+  await SpecialPowers.spawn(bc, [url], function (url) {
+    content.history.pushState({}, "", url);
+  });
+  await loaded;
+  info(`Loaded ${url} ${frameId ? "in an iframe" : ""}`);
+}
+
+async function loadURI(url) {
+  info(`Doing a top-level loadURI, expecting to load ${url}`);
+  let browser = gBrowser.selectedBrowser;
+  let loaded = BrowserTestUtils.browserLoaded(browser, false, url);
+  BrowserTestUtils.startLoadingURIString(browser, url);
+  await loaded;
+  info(`Loaded ${url}`);
+}
+
+async function followLink(url, frameId) {
+  info(
+    `Creating and following a link to ${url} ${frameId ? "in an iframe" : ""}`
+  );
+  let browser = gBrowser.selectedBrowser;
+  let bc = browser.browsingContext;
+  if (frameId) {
+    bc = await SpecialPowers.spawn(bc, [frameId], function (id) {
+      return content.document.getElementById(id).browsingContext;
+    });
+  }
+  let loaded = BrowserTestUtils.browserLoaded(browser, !!frameId, url);
+  await SpecialPowers.spawn(bc, [url], function (url) {
+    let a = content.document.createElement("a");
+    a.href = url;
+    content.document.body.appendChild(a);
+    a.click();
+  });
+  await loaded;
+  info(`Loaded ${url} ${frameId ? "in an iframe" : ""}`);
+}
+
+async function goForward(url, useFrame = false) {
+  info(
+    `Clicking the forward button, expecting to load ${url} ${
+      useFrame ? "in an iframe" : ""
+    }`
+  );
+  let loaded = BrowserTestUtils.waitForLocationChange(gBrowser, url);
+  let forwardButton = document.getElementById("forward-button");
+  forwardButton.click();
+  await loaded;
+  info(`Loaded ${url} ${useFrame ? "in an iframe" : ""}`);
+}
+
+async function goBack(url, useFrame = false) {
+  info(
+    `Clicking the back button, expecting to load ${url} ${
+      useFrame ? "in an iframe" : ""
+    }`
+  );
+  let loaded = BrowserTestUtils.waitForLocationChange(gBrowser, url);
+  let backButton = document.getElementById("back-button");
+  backButton.click();
+  await loaded;
+  info(`Loaded ${url} ${useFrame ? "in an iframe" : ""}`);
+}
+
+function assertBackForwardState(canGoBack, canGoForward) {
+  let backButton = document.getElementById("back-button");
+  let forwardButton = document.getElementById("forward-button");
+
+  is(
+    backButton.disabled,
+    !canGoBack,
+    `${gBrowser.currentURI.spec}: back button is ${
+      canGoBack ? "not" : ""
+    } disabled`
+  );
+  is(
+    forwardButton.disabled,
+    !canGoForward,
+    `${gBrowser.currentURI.spec}: forward button is ${
+      canGoForward ? "not" : ""
+    } disabled`
+  );
+}
+
+class SHListener {
+  static NewEntry = 0;
+  static Reload = 1;
+  static GotoIndex = 2;
+  static Purge = 3;
+  static ReplaceEntry = 4;
+  static async waitForHistory(history, event) {
+    return new Promise(resolve => {
+      let listener = {
+        OnHistoryNewEntry: () => {},
+        OnHistoryReload: () => {
+          return true;
+        },
+        OnHistoryGotoIndex: () => {},
+        OnHistoryPurge: () => {},
+        OnHistoryReplaceEntry: () => {},
+
+        QueryInterface: ChromeUtils.generateQI([
+          "nsISHistoryListener",
+          "nsISupportsWeakReference",
+        ]),
+      };
+
+      function finish() {
+        history.removeSHistoryListener(listener);
+        resolve();
+      }
+      switch (event) {
+        case this.NewEntry:
+          listener.OnHistoryNewEntry = finish;
+          break;
+        case this.Reload:
+          listener.OnHistoryReload = () => {
+            finish();
+            return true;
+          };
+          break;
+        case this.GotoIndex:
+          listener.OnHistoryGotoIndex = finish;
+          break;
+        case this.Purge:
+          listener.OnHistoryPurge = finish;
+          break;
+        case this.ReplaceEntry:
+          listener.OnHistoryReplaceEntry = finish;
+          break;
+      }
+
+      history.addSHistoryListener(listener);
+    });
+  }
+}
diff --git a/docshell/test/browser/head_browser_onbeforeunload.js b/docshell/test/browser/head_browser_onbeforeunload.js
new file mode 100644
index 0000000000..6bb334b793
--- /dev/null
+++ b/docshell/test/browser/head_browser_onbeforeunload.js
@@ -0,0 +1,271 @@
+"use strict";
+
+const BASE_URL = "http://mochi.test:8888/browser/docshell/test/browser/";
+
+const TEST_PAGE = BASE_URL + "file_onbeforeunload_0.html";
+
+const CONTENT_PROMPT_SUBDIALOG = Services.prefs.getBoolPref(
+  "prompts.contentPromptSubDialog",
+  false
+);
+
+const { PromptTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PromptTestUtils.sys.mjs"
+);
+
+async function withTabModalPromptCount(expected, task) {
+  const DIALOG_TOPIC = CONTENT_PROMPT_SUBDIALOG
+    ? "common-dialog-loaded"
+    : "tabmodal-dialog-loaded";
+
+  let count = 0;
+  function observer() {
+    count++;
+  }
+
+  Services.obs.addObserver(observer, DIALOG_TOPIC);
+  try {
+    return await task();
+  } finally {
+    Services.obs.removeObserver(observer, DIALOG_TOPIC);
+    is(count, expected, "Should see expected number of tab modal prompts");
+  }
+}
+
+function promiseAllowUnloadPrompt(browser, allowNavigation) {
+  return PromptTestUtils.handleNextPrompt(
+    browser,
+    { modalType: Services.prompt.MODAL_TYPE_CONTENT, promptType: "confirmEx" },
+    { buttonNumClick: allowNavigation ? 0 : 1 }
+  );
+}
+
+// Maintain a pool of background tabs with our test document loaded so
+// we don't have to wait for a load prior to each test step (potentially
+// tearing down and recreating content processes in the process).
+const TabPool = {
+  poolSize: 5,
+
+  pendingCount: 0,
+
+  readyTabs: [],
+
+  readyPromise: null,
+  resolveReadyPromise: null,
+
+  spawnTabs() {
+    while (this.pendingCount + this.readyTabs.length < this.poolSize) {
+      this.pendingCount++;
+      let tab = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+      BrowserTestUtils.browserLoaded(tab.linkedBrowser).then(() => {
+        this.readyTabs.push(tab);
+        this.pendingCount--;
+
+        if (this.resolveReadyPromise) {
+          this.readyPromise = null;
+          this.resolveReadyPromise();
+          this.resolveReadyPromise = null;
+        }
+
+        this.spawnTabs();
+      });
+    }
+  },
+
+  getReadyPromise() {
+    if (!this.readyPromise) {
+      this.readyPromise = new Promise(resolve => {
+        this.resolveReadyPromise = resolve;
+      });
+    }
+    return this.readyPromise;
+  },
+
+  async getTab() {
+    while (!this.readyTabs.length) {
+      this.spawnTabs();
+      await this.getReadyPromise();
+    }
+
+    let tab = this.readyTabs.shift();
+    this.spawnTabs();
+
+    gBrowser.selectedTab = tab;
+    return tab;
+  },
+
+  async cleanup() {
+    this.poolSize = 0;
+
+    while (this.pendingCount) {
+      await this.getReadyPromise();
+    }
+
+    while (this.readyTabs.length) {
+      await BrowserTestUtils.removeTab(this.readyTabs.shift());
+    }
+  },
+};
+
+const ACTIONS = {
+  NONE: 0,
+  LISTEN_AND_ALLOW: 1,
+  LISTEN_AND_BLOCK: 2,
+};
+
+const ACTION_NAMES = new Map(Object.entries(ACTIONS).map(([k, v]) => [v, k]));
+
+function* generatePermutations(depth) {
+  if (depth == 0) {
+    yield [];
+    return;
+  }
+  for (let subActions of generatePermutations(depth - 1)) {
+    for (let action of Object.values(ACTIONS)) {
+      yield [action, ...subActions];
+    }
+  }
+}
+
+const PERMUTATIONS = Array.from(generatePermutations(4));
+
+const FRAMES = [
+  { process: 0 },
+  { process: SpecialPowers.useRemoteSubframes ? 1 : 0 },
+  { process: 0 },
+  { process: SpecialPowers.useRemoteSubframes ? 1 : 0 },
+];
+
+function addListener(bc, block) {
+  return SpecialPowers.spawn(bc, [block], block => {
+    return new Promise(resolve => {
+      function onbeforeunload(event) {
+        if (block) {
+          event.preventDefault();
+        }
+        resolve({ event: "beforeunload" });
+      }
+      content.addEventListener("beforeunload", onbeforeunload, { once: true });
+      content.unlisten = () => {
+        content.removeEventListener("beforeunload", onbeforeunload);
+      };
+
+      content.addEventListener(
+        "unload",
+        () => {
+          resolve({ event: "unload" });
+        },
+        { once: true }
+      );
+    });
+  });
+}
+
+function descendants(bc) {
+  if (bc) {
+    return [bc, ...descendants(bc.children[0])];
+  }
+  return [];
+}
+
+async function addListeners(frames, actions, startIdx) {
+  let process = startIdx >= 0 ? FRAMES[startIdx].process : -1;
+
+  let roundTripPromises = [];
+
+  let expectNestedEventLoop = false;
+  let numBlockers = 0;
+  let unloadPromises = [];
+  let beforeUnloadPromises = [];
+
+  for (let [i, frame] of frames.entries()) {
+    let action = actions[i];
+    if (action === ACTIONS.NONE) {
+      continue;
+    }
+
+    let block = action === ACTIONS.LISTEN_AND_BLOCK;
+    let promise = addListener(frame, block);
+    if (startIdx <= i) {
+      if (block || FRAMES[i].process !== process) {
+        expectNestedEventLoop = true;
+      }
+      beforeUnloadPromises.push(promise);
+      numBlockers += block;
+    } else {
+      unloadPromises.push(promise);
+    }
+
+    roundTripPromises.push(SpecialPowers.spawn(frame, [], () => {}));
+  }
+
+  // Wait for round trip messages to any processes with event listeners to
+  // return so we're sure that all listeners are registered and their state
+  // flags are propagated before we continue.
+  await Promise.all(roundTripPromises);
+
+  return {
+    expectNestedEventLoop,
+    expectPrompt: !!numBlockers,
+    unloadPromises,
+    beforeUnloadPromises,
+  };
+}
+
+async function doTest(actions, startIdx, navigate) {
+  let tab = await TabPool.getTab();
+  let browser = tab.linkedBrowser;
+
+  let frames = descendants(browser.browsingContext);
+  let expected = await addListeners(frames, actions, startIdx);
+
+  let awaitingPrompt = false;
+  let promptPromise;
+  if (expected.expectPrompt) {
+    awaitingPrompt = true;
+    promptPromise = promiseAllowUnloadPrompt(browser, false).then(() => {
+      awaitingPrompt = false;
+    });
+  }
+
+  let promptCount = expected.expectPrompt ? 1 : 0;
+  await withTabModalPromptCount(promptCount, async () => {
+    await navigate(tab, frames).then(result => {
+      ok(
+        !awaitingPrompt,
+        "Navigation should not complete while we're still expecting a prompt"
+      );
+
+      is(
+        result.eventLoopSpun,
+        expected.expectNestedEventLoop,
+        "Should have nested event loop?"
+      );
+    });
+
+    for (let result of await Promise.all(expected.beforeUnloadPromises)) {
+      is(
+        result.event,
+        "beforeunload",
+        "Should have seen beforeunload event before unload"
+      );
+    }
+    await promptPromise;
+
+    await Promise.all(
+      frames.map(frame =>
+        SpecialPowers.spawn(frame, [], () => {
+          if (content.unlisten) {
+            content.unlisten();
+          }
+        }).catch(() => {})
+      )
+    );
+
+    await BrowserTestUtils.removeTab(tab);
+  });
+
+  for (let result of await Promise.all(expected.unloadPromises)) {
+    is(result.event, "unload", "Should have seen unload event");
+  }
+}
diff --git a/docshell/test/browser/onload_message.html b/docshell/test/browser/onload_message.html
new file mode 100644
index 0000000000..23f6e37396
--- /dev/null
+++ b/docshell/test/browser/onload_message.html
@@ -0,0 +1,25 @@
+<html>
+  <head>
+    <meta charset="utf-8">
+    <script>
+      addEventListener("load", function() {
+        // This file is used in couple of different tests.
+        if (opener) {
+          opener.postMessage("load", "*");
+        } else {
+          var bc = new BroadcastChannel("browser_browsingContext");
+          bc.onmessage = function(event) {
+            if (event.data == "back") {
+              bc.close();
+              history.back();
+            }
+          };
+          bc.postMessage({event: "load", framesLength: frames.length });
+        }
+      });
+    </script>
+  </head>
+  <body>
+    This file posts a message containing "load" to opener or BroadcastChannel on load completion.
+  </body>
+</html>
diff --git a/docshell/test/browser/onpageshow_message.html b/docshell/test/browser/onpageshow_message.html
new file mode 100644
index 0000000000..105c06f8db
--- /dev/null
+++ b/docshell/test/browser/onpageshow_message.html
@@ -0,0 +1,41 @@
+<html>
+  <head>
+    <meta charset="utf-8">
+    <script>
+      addEventListener("pageshow", function() {
+        var bc = new BroadcastChannel("browser_browsingContext");
+        function frameData() {
+          var win = SpecialPowers.wrap(frames[0]);
+          bc.postMessage(
+            { framesLength: frames.length,
+              browsingContextId: win.docShell.browsingContext.id,
+              outerWindowId: win.docShell.outerWindowID
+            });
+        }
+
+        bc.onmessage = function(event) {
+          if (event.data == "createiframe") {
+            let frame = document.createElement("iframe");
+            frame.src = "dummy_page.html";
+            document.body.appendChild(frame);
+            frame.onload = frameData;
+          } else if (event.data == "nextpage") {
+            bc.close();
+            location.href = "onload_message.html";
+          } else if (event.data == "queryframes") {
+            frameData();
+          } else if (event.data == "close") {
+            bc.postMessage("closed");
+            bc.close();
+            window.close();
+          }
+        }
+        bc.postMessage("pageshow");
+      });
+    </script>
+  </head>
+  <body>
+    This file posts a message containing "pageshow" to a BroadcastChannel and
+    keep the channel open for commands.
+  </body>
+</html>
diff --git a/docshell/test/browser/overlink_test.html b/docshell/test/browser/overlink_test.html
new file mode 100644
index 0000000000..5efd689311
--- /dev/null
+++ b/docshell/test/browser/overlink_test.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head> <meta charset="utf-8"> </head>
+  <body>
+    <a id="link" href="https://user:password@example.com">Link</a>
+  </body>
+</html>
diff --git a/docshell/test/browser/print_postdata.sjs b/docshell/test/browser/print_postdata.sjs
new file mode 100644
index 0000000000..0e3ef38419
--- /dev/null
+++ b/docshell/test/browser/print_postdata.sjs
@@ -0,0 +1,25 @@
+const CC = Components.Constructor;
+const BinaryInputStream = CC(
+  "@mozilla.org/binaryinputstream;1",
+  "nsIBinaryInputStream",
+  "setInputStream"
+);
+
+function handleRequest(request, response) {
+  response.setHeader("Content-Type", "text/plain", false);
+  if (request.method == "GET") {
+    response.write(request.queryString);
+  } else {
+    var body = new BinaryInputStream(request.bodyInputStream);
+
+    var avail;
+    var bytes = [];
+
+    while ((avail = body.available()) > 0) {
+      Array.prototype.push.apply(bytes, body.readByteArray(avail));
+    }
+
+    var data = String.fromCharCode.apply(null, bytes);
+    response.bodyOutputStream.write(data, data.length);
+  }
+}
diff --git a/docshell/test/browser/redirect_to_example.sjs b/docshell/test/browser/redirect_to_example.sjs
new file mode 100644
index 0000000000..283e4793db
--- /dev/null
+++ b/docshell/test/browser/redirect_to_example.sjs
@@ -0,0 +1,5 @@
+function handleRequest(request, response) {
+  response.setStatusLine(request.httpVersion, 302, "Moved Permanently");
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  response.setHeader("Location", "http://example");
+}
diff --git a/docshell/test/browser/test-form_sjis.html b/docshell/test/browser/test-form_sjis.html
new file mode 100644
index 0000000000..91c375deef
--- /dev/null
+++ b/docshell/test/browser/test-form_sjis.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
+ "http://www.w3.org/TR/REC-html401-19991224/strict.dtd">
+<html>
+ <head>
+  <meta http-equiv="content-type" content="text/html; charset=windows-1251">
+  <title>Shift_JIS in body and text area</title>
+ </head>
+ <body>
+  <h1>Incorrect meta charset</h1>
+  <h2>This page is encoded in Shift_JIS, but has an incorrect meta charset
+     claiming that it is windows-1251</h2>
+  <p id="testpar">ƒ†ƒjƒR[ƒh‚́A‚·‚Χ‚Δ‚Μ•ΆŽš‚ΙŒΕ—L‚̔ԍ†‚π•t—^‚΅‚ά‚·</p>
+  <form>
+  <p>
+   <textarea id="testtextarea" rows=6 cols=60>ƒ†ƒjƒR[ƒh‚́A‚·‚Χ‚Δ‚Μ•ΆŽš‚ΙŒΕ—L‚̔ԍ†‚π•t—^‚΅‚ά‚·</textarea>
+   <input id="testinput" type="text" size=60 value="ƒ†ƒjƒR[ƒh‚́A‚·‚Χ‚Δ‚Μ•ΆŽš‚ΙŒΕ—L‚̔ԍ†‚π•t—^‚΅‚ά‚·">
+  </p>
+  </form>
+  <h2>Expected text on load:</h2>
+  <p>&#x453;&#x2020;&#x453;&#x6A;&#x453;&#x52;&#x403;&#x5B;&#x453;&#x68;&#x201A;&#x41D;&#x403;&#x41;&#x201A;&#xB7;&#x201A;&#x427;&#x201A;&#x414;&#x201A;&#x41C;&#x2022;&#xB6;&#x40B;&#x459;&#x201A;&#x419;&#x40A;&#x415;&#x2014;&#x4C;&#x201A;&#x41C;&#x201D;&#x424;&#x40C;&#x2020;&#x201A;&#x440;&#x2022;&#x74;&#x2014;&#x5E;&#x201A;&#xB5;&#x201A;&#x42C;&#x201A;&#xB7;</p>
+  <h2>Expected text on resetting the encoding to Shift_JIS:</h2>
+  <p>&#x30E6;&#x30CB;&#x30B3;&#x30FC;&#x30C9;&#x306F;&#x3001;&#x3059;&#x3079;&#x3066;&#x306E;&#x6587;&#x5B57;&#x306B;&#x56FA;&#x6709;&#x306E;&#x756A;&#x53F7;&#x3092;&#x4ED8;&#x4E0E;&#x3057;&#x307E;&#x3059;</p>
+ </body>
+</html>