Backed out 10 changesets (bug 1501044, bug 1472212) for fetch-destination.https.html perma failure CLOSED TREE
authorCiure Andrei <aciure@mozilla.com>
Tue, 30 Oct 2018 23:31:10 +0200
changeset 443516 dff3cfb50f19
parent 443515 26bc7f3c808d
child 443517 c5c10f26e38c
push id109409
push useraciure@mozilla.com
push dateTue, 30 Oct 2018 21:32:36 +0000
treeherdermozilla-inbound@dff3cfb50f19 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1501044, 1472212
milestone65.0a1
backs outaa35078cabaa
bf02793f802d
95a7ef6102a6
7b7fa6ab2229
4fe4ec18f2f3
18f824674b76
1978a7837502
21a6f1a83c73
48242d39d532
0b5cf2f4305a
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 10 changesets (bug 1501044, bug 1472212) for fetch-destination.https.html perma failure CLOSED TREE Backed out changeset aa35078cabaa (bug 1472212) Backed out changeset bf02793f802d (bug 1472212) Backed out changeset 95a7ef6102a6 (bug 1472212) Backed out changeset 7b7fa6ab2229 (bug 1472212) Backed out changeset 4fe4ec18f2f3 (bug 1472212) Backed out changeset 18f824674b76 (bug 1472212) Backed out changeset 1978a7837502 (bug 1472212) Backed out changeset 21a6f1a83c73 (bug 1472212) Backed out changeset 48242d39d532 (bug 1472212) Backed out changeset 0b5cf2f4305a (bug 1501044)
browser/app/profile/firefox.js
browser/base/content/tabbrowser.js
browser/base/content/test/general/browser_e10s_about_process.js
browser/base/content/test/general/browser_e10s_chrome_process.js
browser/base/content/test/general/browser_e10s_javascript.js
browser/base/content/test/tabs/browser_isLocalAboutURI.js
browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
browser/components/newtab/aboutNewTabService.js
browser/components/newtab/test/browser/browser_packaged_as_locales.js
browser/components/newtab/test/xpcshell/test_AboutNewTabService.js
browser/components/sessionstore/SessionStore.jsm
browser/components/uitour/UITour.jsm
browser/modules/AsyncTabSwitcher.jsm
devtools/client/responsive.html/browser/swap.js
dom/xhr/tests/browser_xhr_onchange_leak.js
js/xpconnect/tests/browser/browser_dead_object.js
testing/mochitest/BrowserTestUtils/BrowserTestUtils.jsm
testing/web-platform/meta/fetch/api/request/destination/fetch-destination.https.html.ini
toolkit/content/tests/browser/browser_findbar.js
toolkit/modules/E10SUtils.jsm
toolkit/mozapps/extensions/content/extensions.js
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -463,21 +463,16 @@ pref("browser.tabs.extraDragSpace", fals
 // true   return to the tab that opened this tab (its owner)
 // false  return to the adjacent tab (old default)
 pref("browser.tabs.selectOwnerOnClose", true);
 
 pref("browser.tabs.showAudioPlayingIcon", true);
 // This should match Chromium's audio indicator delay.
 pref("browser.tabs.delayHidingAudioPlayingIconMS", 3000);
 
-// Pref to control whether we use separate privileged content processes.
-#if defined(NIGHTLY_BUILD) && !defined(MOZ_ASAN)
-pref("browser.tabs.remote.separatePrivilegedContentProcess", true);
-#endif
-
 pref("browser.ctrlTab.recentlyUsedOrder", true);
 
 // By default, do not export HTML at shutdown.
 // If true, at shutdown the bookmarks in your menu and toolbar will
 // be exported as HTML to the bookmarks.html file.
 pref("browser.bookmarks.autoExportHTML",          false);
 
 // The maximum number of daily bookmark backups to
--- a/browser/base/content/tabbrowser.js
+++ b/browser/base/content/tabbrowser.js
@@ -705,17 +705,17 @@ window._gBrowser = {
     }
 
     return rv;
   },
 
   /**
    * Determine if a URI is an about: page pointing to a local resource.
    */
-  isLocalAboutURI(aURI, aResolvedURI) {
+  _isLocalAboutURI(aURI, aResolvedURI) {
     if (!aURI.schemeIs("about")) {
       return false;
     }
 
     // Specially handle about:blank as local
     if (aURI.pathQueryRef === "blank") {
       return true;
     }
@@ -732,25 +732,16 @@ window._gBrowser = {
       ).URI;
       return resolvedURI.schemeIs("jar") || resolvedURI.schemeIs("file");
     } catch (ex) {
       // aURI might be invalid.
       return false;
     }
   },
 
-  /**
-   * Sets an icon for the tab if the URI is defined in FAVICON_DEFAULTS.
-   */
-  setDefaultIcon(aTab, aURI) {
-    if (aURI && aURI.spec in FAVICON_DEFAULTS) {
-      this.setIcon(aTab, FAVICON_DEFAULTS[aURI.spec]);
-    }
-  },
-
   setIcon(aTab, aIconURL = "", aOriginalURL = aIconURL, aLoadingPrincipal = null) {
     let makeString = (url) => url instanceof Ci.nsIURI ? url.spec : url;
 
     aIconURL = makeString(aIconURL);
     aOriginalURL = makeString(aOriginalURL);
 
     let LOCAL_PROTOCOLS = [
       "chrome:",
@@ -2509,17 +2500,19 @@ window._gBrowser = {
         let notificationbox = this.getNotificationBox(t.linkedBrowser);
         notificationbox.remove();
       }
       throw e;
     }
 
     // Hack to ensure that the about:newtab, and about:welcome favicon is loaded
     // instantaneously, to avoid flickering and improve perceived performance.
-    this.setDefaultIcon(t, aURIObject);
+    if (aURI in FAVICON_DEFAULTS) {
+      this.setIcon(t, FAVICON_DEFAULTS[aURI]);
+    }
 
     // Dispatch a new tab notification.  We do this once we're
     // entirely done, so that things are in a consistent state
     // even if the event listener opens or closes tabs.
     let evt = new CustomEvent("TabOpen", { bubbles: true, detail: eventDetail || {} });
     t.dispatchEvent(evt);
 
     if (!usingPreloadedContent && originPrincipal && aURI) {
@@ -4818,17 +4811,17 @@ class TabProgressListener {
 
   _shouldShowProgress(aRequest) {
     if (this.mBlank)
       return false;
 
     // Don't show progress indicators in tabs for about: URIs
     // pointing to local resources.
     if ((aRequest instanceof Ci.nsIChannel) &&
-        gBrowser.isLocalAboutURI(aRequest.originalURI, aRequest.URI)) {
+        gBrowser._isLocalAboutURI(aRequest.originalURI, aRequest.URI)) {
       return false;
     }
 
     return true;
   }
 
   _isForInitialAboutBlank(aWebProgress, aStateFlags, aLocation) {
     if (!this.mBlank || !aWebProgress.isTopLevel) {
--- a/browser/base/content/test/general/browser_e10s_about_process.js
+++ b/browser/base/content/test/general/browser_e10s_about_process.js
@@ -1,39 +1,31 @@
-const CHROME_PROCESS = E10SUtils.NOT_REMOTE;
-const WEB_CONTENT_PROCESS = E10SUtils.WEB_REMOTE_TYPE;
-const PRIVILEGED_CONTENT_PROCESS = E10SUtils.PRIVILEGED_REMOTE_TYPE;
+const CHROME_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+const CONTENT_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT;
 
 const CHROME = {
   id: "cb34538a-d9da-40f3-b61a-069f0b2cb9fb",
   path: "test-chrome",
   flags: 0,
 };
 const CANREMOTE = {
   id: "2480d3e1-9ce4-4b84-8ae3-910b9a95cbb3",
   path: "test-allowremote",
   flags: Ci.nsIAboutModule.URI_CAN_LOAD_IN_CHILD,
 };
 const MUSTREMOTE = {
   id: "f849cee5-e13e-44d2-981d-0fb3884aaead",
   path: "test-mustremote",
   flags: Ci.nsIAboutModule.URI_MUST_LOAD_IN_CHILD,
 };
-const CANPRIVILEGEDREMOTE = {
-  id: "a04ffafe-6c63-4266-acae-0f4b093165aa",
-  path: "test-canprivilegedremote",
-  flags: Ci.nsIAboutModule.URI_MUST_LOAD_IN_CHILD |
-         Ci.nsIAboutModule.URI_CAN_LOAD_IN_PRIVILEGED_CHILD,
-};
 
 const TEST_MODULES = [
   CHROME,
   CANREMOTE,
   MUSTREMOTE,
-  CANPRIVILEGEDREMOTE,
 ];
 
 function AboutModule() {
 }
 
 AboutModule.prototype = {
   newChannel(aURI, aLoadInfo) {
     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
@@ -82,75 +74,41 @@ add_task(async function init() {
 
 registerCleanupFunction(() => {
   let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
   for (let module of TEST_MODULES) {
     registrar.unregisterFactory(Components.ID(module.id), AboutModuleFactory);
   }
 });
 
-function test_url(url, chromeResult, webContentResult, privilegedContentResult) {
-  is(E10SUtils.canLoadURIInRemoteType(url, CHROME_PROCESS),
+function test_url(url, chromeResult, contentResult) {
+  is(E10SUtils.canLoadURIInProcess(url, CHROME_PROCESS),
      chromeResult, "Check URL in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url, WEB_CONTENT_PROCESS),
-     webContentResult, "Check URL in web content process.");
-  is(E10SUtils.canLoadURIInRemoteType(url, PRIVILEGED_CONTENT_PROCESS),
-     privilegedContentResult, "Check URL in privileged content process.");
+  is(E10SUtils.canLoadURIInProcess(url, CONTENT_PROCESS),
+     contentResult, "Check URL in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "#foo", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "#foo", CHROME_PROCESS),
      chromeResult, "Check URL with ref in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "#foo", WEB_CONTENT_PROCESS),
-     webContentResult, "Check URL with ref in web content process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "#foo", PRIVILEGED_CONTENT_PROCESS),
-     privilegedContentResult, "Check URL with ref in privileged content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "#foo", CONTENT_PROCESS),
+     contentResult, "Check URL with ref in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "?foo", CHROME_PROCESS),
      chromeResult, "Check URL with query in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo", WEB_CONTENT_PROCESS),
-     webContentResult, "Check URL with query in web content process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo", PRIVILEGED_CONTENT_PROCESS),
-     privilegedContentResult, "Check URL with query in privileged content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "?foo", CONTENT_PROCESS),
+     contentResult, "Check URL with query in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo#bar", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "?foo#bar", CHROME_PROCESS),
      chromeResult, "Check URL with query and ref in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo#bar", WEB_CONTENT_PROCESS),
-     webContentResult, "Check URL with query and ref in web content process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo#bar", PRIVILEGED_CONTENT_PROCESS),
-     privilegedContentResult, "Check URL with query and ref in privileged content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "?foo#bar", CONTENT_PROCESS),
+     contentResult, "Check URL with query and ref in content process.");
 }
 
 add_task(async function test_chrome() {
-  test_url("about:" + CHROME.path, true, false, false);
+  test_url("about:" + CHROME.path, true, false);
 });
 
 add_task(async function test_any() {
-  test_url("about:" + CANREMOTE.path, true, true, false);
+  test_url("about:" + CANREMOTE.path, true, true);
 });
 
 add_task(async function test_remote() {
-  test_url("about:" + MUSTREMOTE.path, false, true, false);
+  test_url("about:" + MUSTREMOTE.path, false, true);
 });
-
-add_task(async function test_privileged_remote_true() {
-  await SpecialPowers.pushPrefEnv({
-    set: [
-      ["browser.tabs.remote.separatePrivilegedContentProcess", true],
-    ],
-  });
-
-  // This shouldn't be taken literally. We will always use the privileged
-  // content type if the URI_CAN_LOAD_IN_PRIVILEGED_CHILD flag is enabled and
-  // the pref is turned on.
-  test_url("about:" + CANPRIVILEGEDREMOTE.path, false, false, true);
-});
-
-add_task(async function test_privileged_remote_false() {
-  await SpecialPowers.pushPrefEnv({
-    set: [
-      ["browser.tabs.remote.separatePrivilegedContentProcess", false],
-    ],
-  });
-
-  // This shouldn't be taken literally. We will always use the privileged
-  // content type if the URI_CAN_LOAD_IN_PRIVILEGED_CHILD flag is enabled and
-  // the pref is turned on.
-  test_url("about:" + CANPRIVILEGEDREMOTE.path, false, true, false);
-});
--- a/browser/base/content/test/general/browser_e10s_chrome_process.js
+++ b/browser/base/content/test/general/browser_e10s_chrome_process.js
@@ -27,52 +27,52 @@ function makeTest(name, startURL, startP
     }
     await docLoadedPromise;
 
     is(browser.currentURI.spec, endURL, "Should have made it to the final URL");
     is(browser.isRemoteBrowser, endProcessIsRemote, "Should be displayed in the right process");
   };
 }
 
-const CHROME_PROCESS = E10SUtils.NOT_REMOTE;
-const WEB_CONTENT_PROCESS = E10SUtils.WEB_REMOTE_TYPE;
+const CHROME_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+const CONTENT_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT;
 const PATH = (getRootDirectory(gTestPath) + "test_process_flags_chrome.html").replace("chrome://mochitests", "");
 
 const CHROME = "chrome://mochitests" + PATH;
 const CANREMOTE = "chrome://mochitests-any" + PATH;
 const MUSTREMOTE = "chrome://mochitests-content" + PATH;
 
 add_task(async function init() {
   gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, "about:blank", {forceNotRemote: true});
 });
 
 registerCleanupFunction(() => {
   gBrowser.removeCurrentTab();
 });
 
 function test_url(url, chromeResult, contentResult) {
-  is(E10SUtils.canLoadURIInRemoteType(url, CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url, CHROME_PROCESS),
      chromeResult, "Check URL in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url, WEB_CONTENT_PROCESS),
-     contentResult, "Check URL in web content process.");
+  is(E10SUtils.canLoadURIInProcess(url, CONTENT_PROCESS),
+     contentResult, "Check URL in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "#foo", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "#foo", CHROME_PROCESS),
      chromeResult, "Check URL with ref in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "#foo", WEB_CONTENT_PROCESS),
-     contentResult, "Check URL with ref in web content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "#foo", CONTENT_PROCESS),
+     contentResult, "Check URL with ref in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "?foo", CHROME_PROCESS),
      chromeResult, "Check URL with query in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo", WEB_CONTENT_PROCESS),
-     contentResult, "Check URL with query in web content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "?foo", CONTENT_PROCESS),
+     contentResult, "Check URL with query in content process.");
 
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo#bar", CHROME_PROCESS),
+  is(E10SUtils.canLoadURIInProcess(url + "?foo#bar", CHROME_PROCESS),
      chromeResult, "Check URL with query and ref in chrome process.");
-  is(E10SUtils.canLoadURIInRemoteType(url + "?foo#bar", WEB_CONTENT_PROCESS),
-     contentResult, "Check URL with query and ref in web content process.");
+  is(E10SUtils.canLoadURIInProcess(url + "?foo#bar", CONTENT_PROCESS),
+     contentResult, "Check URL with query and ref in content process.");
 }
 
 add_task(async function test_chrome() {
   test_url(CHROME, true, false);
 });
 
 add_task(async function test_any() {
   test_url(CANREMOTE, true, true);
--- a/browser/base/content/test/general/browser_e10s_javascript.js
+++ b/browser/base/content/test/general/browser_e10s_javascript.js
@@ -1,11 +1,11 @@
-const CHROME_PROCESS = E10SUtils.NOT_REMOTE;
-const WEB_CONTENT_PROCESS = E10SUtils.WEB_REMOTE_TYPE;
+const CHROME_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+const CONTENT_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT;
 
 add_task(async function() {
   let url = "javascript:dosomething()";
 
-  ok(E10SUtils.canLoadURIInRemoteType(url, CHROME_PROCESS),
+  ok(E10SUtils.canLoadURIInProcess(url, CHROME_PROCESS),
      "Check URL in chrome process.");
-  ok(E10SUtils.canLoadURIInRemoteType(url, WEB_CONTENT_PROCESS),
-     "Check URL in web content process.");
+  ok(E10SUtils.canLoadURIInProcess(url, CONTENT_PROCESS),
+     "Check URL in content process.");
 });
--- a/browser/base/content/test/tabs/browser_isLocalAboutURI.js
+++ b/browser/base/content/test/tabs/browser_isLocalAboutURI.js
@@ -1,41 +1,41 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
 /**
- * Unit tests for tabbrowser.isLocalAboutURI to make sure it returns the
+ * Unit tests for tabbrowser._isLocalAboutURI to make sure it returns the
  * appropriate values for various URIs as well as optional resolved URI.
  */
 
 add_task(function test_URI() {
   const check = (spec, expect, description) => {
     const URI = Services.io.newURI(spec);
     try {
-      is(gBrowser.isLocalAboutURI(URI), expect, description);
+      is(gBrowser._isLocalAboutURI(URI), expect, description);
     } catch (ex) {
-      ok(false, "isLocalAboutURI should not throw");
+      ok(false, "_isLocalAboutURI should not throw");
     }
   };
   check("https://www.mozilla.org/", false, "https is not about");
   check("http://www.mozilla.org/", false, "http is not about");
   check("about:blank", true, "about:blank is local");
   check("about:about", true, "about:about is local");
   check("about:newtab", true, "about:newtab is local");
   check("about:random-invalid-uri", false,
         "about:random-invalid-uri is invalid but should not throw");
 });
 
 add_task(function test_URI_with_resolved() {
   const check = (spec, resolvedSpec, expect, description) => {
     const URI = Services.io.newURI(spec);
     const resolvedURI = Services.io.newURI(resolvedSpec);
-    is(gBrowser.isLocalAboutURI(URI, resolvedURI), expect, description);
+    is(gBrowser._isLocalAboutURI(URI, resolvedURI), expect, description);
   };
   check("about:newtab",
     "jar:file:///Applications/Firefox.app/Contents/Resources/browser/omni.ja!/chrome/browser/res/activity-stream/prerendered/en-US/activity-stream.html",
     true,
     "about:newtab with jar is local");
   check("about:newtab",
     "file:///mozilla-central/browser/base/content/newtab/newTab.xhtml",
     true,
--- a/browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
+++ b/browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
@@ -25,17 +25,17 @@ const TEST_HTTP = "http://example.org/";
  * @param {string} expectedRemoteType
  *        The expected remoteType value for the browser in both the parent
  *        and child processes.
  * @param {optional string} message
  *        If provided, shows this string as the message when remoteType values
  *        do not match. If not present, it uses the default message defined
  *        in the function parameters.
  */
-function checkBrowserRemoteType(
+async function checkBrowserRemoteType(
   browser,
   expectedRemoteType,
   message = `Ensures that tab runs in the ${expectedRemoteType} content process.`
 ) {
   // Check both parent and child to ensure that they have the correct remoteType.
   is(browser.remoteType, expectedRemoteType, message);
   is(browser.messageManager.remoteType, expectedRemoteType,
     "Parent and child process should agree on the remote type.");
@@ -58,17 +58,17 @@ add_task(async function setup() {
  * the privileged content process. With the reference, we can then open Activity
  * Stream links in a new tab and ensure that the new tab opens in the same
  * privileged content process as our reference.
  */
 add_task(async function activity_stream_in_privileged_content_process() {
   Services.ppmm.releaseCachedProcesses();
 
   await BrowserTestUtils.withNewTab(ABOUT_NEWTAB, async function(browser1) {
-    checkBrowserRemoteType(browser1, E10SUtils.PRIVILEGED_REMOTE_TYPE);
+    await checkBrowserRemoteType(browser1, E10SUtils.PRIVILEGED_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
     let privilegedPid = browser1.frameLoader.tabParent.osPid;
 
     for (let url of [
       ABOUT_NEWTAB,
       ABOUT_WELCOME,
       ABOUT_HOME,
@@ -92,17 +92,17 @@ add_task(async function activity_stream_
 /*
  * Test to ensure that a process switch occurs when navigating between normal
  * web pages and Activity Stream pages in the same tab.
  */
 add_task(async function process_switching_through_loading_in_the_same_tab() {
   Services.ppmm.releaseCachedProcesses();
 
   await BrowserTestUtils.withNewTab(TEST_HTTP, async function(browser) {
-    checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
+    await checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
 
     for (let [url, remoteType] of [
       [ABOUT_NEWTAB, E10SUtils.PRIVILEGED_REMOTE_TYPE],
       [ABOUT_BLANK, E10SUtils.PRIVILEGED_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
       [ABOUT_HOME, E10SUtils.PRIVILEGED_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
       [ABOUT_WELCOME, E10SUtils.PRIVILEGED_REMOTE_TYPE],
@@ -118,33 +118,33 @@ add_task(async function process_switchin
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
       [`${ABOUT_WELCOME}?q=bar`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
       [`${ABOUT_HOME}?q=baz`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
     ]) {
       BrowserTestUtils.loadURI(browser, url);
       await BrowserTestUtils.browserLoaded(browser, false, url);
-      checkBrowserRemoteType(browser, remoteType);
+      await checkBrowserRemoteType(browser, remoteType);
     }
   });
 
   Services.ppmm.releaseCachedProcesses();
 });
 
 /*
  * Test to ensure that a process switch occurs when navigating between normal
  * web pages and Activity Stream pages using the browser's navigation features
  * such as history and location change.
  */
 add_task(async function process_switching_through_navigation_features() {
   Services.ppmm.releaseCachedProcesses();
 
   await BrowserTestUtils.withNewTab(ABOUT_NEWTAB, async function(browser) {
-    checkBrowserRemoteType(browser, E10SUtils.PRIVILEGED_REMOTE_TYPE);
+    await checkBrowserRemoteType(browser, E10SUtils.PRIVILEGED_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
     let privilegedPid = browser.frameLoader.tabParent.osPid;
 
     // Check that about:newtab opened from JS in about:newtab page is in the same process.
     let promiseTabOpened = BrowserTestUtils.waitForNewTab(gBrowser, ABOUT_NEWTAB, true);
     await ContentTask.spawn(browser, ABOUT_NEWTAB, uri => {
       content.open(uri, "_blank");
@@ -161,17 +161,17 @@ add_task(async function process_switchin
     BrowserReload();
     await BrowserTestUtils.browserLoaded(browser, false, ABOUT_NEWTAB);
     is(browser.frameLoader.tabParent.osPid, privilegedPid,
       "Check that about:newtab is still in privileged content process after reload.");
 
     // Load http webpage
     BrowserTestUtils.loadURI(browser, TEST_HTTP);
     await BrowserTestUtils.browserLoaded(browser, false, TEST_HTTP);
-    checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
+    await checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
 
     // Check that using the history back feature switches back to privileged content process.
     let promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, ABOUT_NEWTAB);
     browser.goBack();
     await promiseLocation;
     // We will need to ensure that the process flip has fully completed so that
     // the navigation history data will be available when we do browser.goForward();
     await BrowserTestUtils.waitForEvent(newTab, "SSTabRestored");
@@ -180,29 +180,29 @@ add_task(async function process_switchin
 
     // Check that using the history forward feature switches back to the web content process.
     promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, TEST_HTTP);
     browser.goForward();
     await promiseLocation;
     // We will need to ensure that the process flip has fully completed so that
     // the navigation history data will be available when we do browser.gotoIndex(0);
     await BrowserTestUtils.waitForEvent(newTab, "SSTabRestored");
-    checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE,
+    await checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE,
       "Check that tab runs in the web content process after using history goForward.");
 
     // Check that goto history index does not break the affinity.
     promiseLocation = BrowserTestUtils.waitForLocationChange(gBrowser, ABOUT_NEWTAB);
     browser.gotoIndex(0);
     await promiseLocation;
     is(browser.frameLoader.tabParent.osPid, privilegedPid,
       "Check that about:newtab is in privileged content process after history gotoIndex.");
 
     BrowserTestUtils.loadURI(browser, TEST_HTTP);
     await BrowserTestUtils.browserLoaded(browser, false, TEST_HTTP);
-    checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
+    await checkBrowserRemoteType(browser, E10SUtils.WEB_REMOTE_TYPE);
 
     // Check that location change causes a change in process type as well.
     await ContentTask.spawn(browser, ABOUT_NEWTAB, uri => {
       content.location = uri;
     });
     await BrowserTestUtils.browserLoaded(browser, false, ABOUT_NEWTAB);
     is(browser.frameLoader.tabParent.osPid, privilegedPid,
       "Check that about:newtab is in privileged content process after location change.");
--- a/browser/components/newtab/aboutNewTabService.js
+++ b/browser/components/newtab/aboutNewTabService.js
@@ -103,17 +103,16 @@ AboutNewTabService.prototype = {
     Ci.nsIObserver,
   ]),
 
   observe(subject, topic, data) {
     switch (topic) {
       case "nsPref:changed":
         if (data === PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS) {
           this._privilegedContentProcess = Services.prefs.getBoolPref(PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS);
-          this.notifyChange();
         } else if (data === PREF_ACTIVITY_STREAM_PRERENDER_ENABLED) {
           this._activityStreamPrerender = Services.prefs.getBoolPref(PREF_ACTIVITY_STREAM_PRERENDER_ENABLED);
           this.notifyChange();
         } else if (!IS_RELEASE_OR_BETA && data === PREF_ACTIVITY_STREAM_DEBUG) {
           this._activityStreamDebug = Services.prefs.getBoolPref(PREF_ACTIVITY_STREAM_DEBUG, false);
           this.updatePrerenderedPath();
           this.notifyChange();
         }
--- a/browser/components/newtab/test/browser/browser_packaged_as_locales.js
+++ b/browser/components/newtab/test/browser/browser_packaged_as_locales.js
@@ -1,17 +1,15 @@
 ChromeUtils.import("resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "aboutNewTabService",
                                    "@mozilla.org/browser/aboutnewtab-service;1",
                                    "nsIAboutNewTabService");
 
 // Tests are by default run with non-debug en-US configuration
-const DEFAULT_URL = SpecialPowers.getBoolPref("browser.tabs.remote.separatePrivilegedContentProcess")
-  ? "resource://activity-stream/prerendered/en-US/activity-stream-prerendered-noscripts.html"
-  : "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
+const DEFAULT_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
 
 /**
  * Temporarily change the app locale to get the localized activity stream url
  */
 async function getUrlForLocale(locale) {
   const origAvailable = Services.locale.availableLocales;
   const origRequested = Services.locale.requestedLocales;
   try {
--- a/browser/components/newtab/test/xpcshell/test_AboutNewTabService.js
+++ b/browser/components/newtab/test/xpcshell/test_AboutNewTabService.js
@@ -9,65 +9,33 @@ ChromeUtils.import("resource://gre/modul
 ChromeUtils.import("resource://gre/modules/Preferences.jsm");
 ChromeUtils.import("resource://gre/modules/AppConstants.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "aboutNewTabService",
                                    "@mozilla.org/browser/aboutnewtab-service;1",
                                    "nsIAboutNewTabService");
 
 const IS_RELEASE_OR_BETA = AppConstants.RELEASE_OR_BETA;
 
+const ACTIVITY_STREAM_PRERENDER_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
+const ACTIVITY_STREAM_PRERENDER_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-prerendered-debug.html";
+const ACTIVITY_STREAM_URL = "resource://activity-stream/prerendered/en-US/activity-stream.html";
+const ACTIVITY_STREAM_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-debug.html";
+
 const DOWNLOADS_URL = "chrome://browser/content/downloads/contentAreaDownloadsView.xul";
-const SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF = "browser.tabs.remote.separatePrivilegedContentProcess";
 const ACTIVITY_STREAM_PRERENDER_PREF = "browser.newtabpage.activity-stream.prerender";
 const ACTIVITY_STREAM_DEBUG_PREF = "browser.newtabpage.activity-stream.debug";
 
 function cleanup() {
-  Services.prefs.clearUserPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_PRERENDER_PREF);
   Services.prefs.clearUserPref(ACTIVITY_STREAM_DEBUG_PREF);
   aboutNewTabService.resetNewTabURL();
 }
 
 registerCleanupFunction(cleanup);
 
-let ACTIVITY_STREAM_PRERENDER_URL;
-let ACTIVITY_STREAM_PRERENDER_DEBUG_URL;
-let ACTIVITY_STREAM_URL;
-let ACTIVITY_STREAM_DEBUG_URL;
-
-function setExpectedUrlsWithScripts() {
-  ACTIVITY_STREAM_PRERENDER_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html";
-  ACTIVITY_STREAM_PRERENDER_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-prerendered-debug.html";
-  ACTIVITY_STREAM_URL = "resource://activity-stream/prerendered/en-US/activity-stream.html";
-  ACTIVITY_STREAM_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-debug.html";
-}
-
-function setExpectedUrlsWithoutScripts() {
-  ACTIVITY_STREAM_PRERENDER_URL = "resource://activity-stream/prerendered/en-US/activity-stream-prerendered-noscripts.html";
-  ACTIVITY_STREAM_PRERENDER_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-prerendered-debug-noscripts.html";
-  ACTIVITY_STREAM_URL = "resource://activity-stream/prerendered/en-US/activity-stream-noscripts.html";
-  ACTIVITY_STREAM_DEBUG_URL = "resource://activity-stream/prerendered/static/activity-stream-debug-noscripts.html";
-}
-
-// Default expected URLs to files with scripts in them.
-setExpectedUrlsWithScripts();
-
-function addTestsWithPrivilegedContentProcessPref(test) {
-  add_task(async() => {
-    await setPrivilegedContentProcessPref(true);
-    setExpectedUrlsWithoutScripts();
-    await test();
-  });
-  add_task(async() => {
-    await setPrivilegedContentProcessPref(false);
-    setExpectedUrlsWithScripts();
-    await test();
-  });
-}
-
 function nextChangeNotificationPromise(aNewURL, testMessage) {
   return new Promise(resolve => {
     Services.obs.addObserver(function observer(aSubject, aTopic, aData) { // jshint unused:false
       Services.obs.removeObserver(observer, aTopic);
       Assert.equal(aData, aNewURL, testMessage);
       resolve();
     }, "newtab-url-changed");
   });
@@ -90,26 +58,16 @@ function setupASPrerendered() {
     return Promise.resolve();
   }
 
   let notificationPromise = nextChangeNotificationPromise("about:newtab");
   Services.prefs.setBoolPref(ACTIVITY_STREAM_PRERENDER_PREF, true);
   return notificationPromise;
 }
 
-function setPrivilegedContentProcessPref(usePrivilegedContentProcess) {
-  if (usePrivilegedContentProcess === Services.prefs.getBoolPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF)) {
-    return Promise.resolve();
-  }
-
-  let notificationPromise = nextChangeNotificationPromise("about:newtab");
-  Services.prefs.setBoolPref(SEPARATE_PRIVILEGED_CONTENT_PROCESS_PREF, usePrivilegedContentProcess);
-  return notificationPromise;
-}
-
 add_task(async function test_as_and_prerender_initialized() {
   Assert.ok(aboutNewTabService.activityStreamEnabled,
     ".activityStreamEnabled should be set to the correct initial value");
   Assert.equal(aboutNewTabService.activityStreamPrerender, Services.prefs.getBoolPref(ACTIVITY_STREAM_PRERENDER_PREF),
     ".activityStreamPrerender should be set to the correct initial value");
   // This pref isn't defined on release or beta, so we fall back to false
   Assert.equal(aboutNewTabService.activityStreamDebug, Services.prefs.getBoolPref(ACTIVITY_STREAM_DEBUG_PREF, false),
     ".activityStreamDebug should be set to the correct initial value");
@@ -142,21 +100,20 @@ add_task(async function test_override_ac
   aboutNewTabService.newTabURL = DOWNLOADS_URL;
   await notificationPromise;
   Assert.ok(aboutNewTabService.overridden, "Newtab URL should be overridden");
   Assert.equal(aboutNewTabService.newTabURL, DOWNLOADS_URL, "Newtab URL should be the custom URL");
 
   cleanup();
 });
 
-addTestsWithPrivilegedContentProcessPref(async function test_override_activity_stream_enabled() {
+add_task(async function test_override_activity_stream_enabled() {
   let notificationPromise = await setupASPrerendered();
 
-  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL,
-    "Newtab URL should be the default activity stream prerendered URL");
+  Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL, "Newtab URL should be the default activity stream prerendered URL");
   Assert.ok(!aboutNewTabService.overridden, "Newtab URL should not be overridden");
   Assert.ok(aboutNewTabService.activityStreamEnabled, "Activity Stream should be enabled");
   Assert.ok(aboutNewTabService.activityStreamPrerender, "Activity Stream should be prerendered");
 
   // change to a chrome URL while activity stream is enabled
   notificationPromise = nextChangeNotificationPromise(DOWNLOADS_URL);
   aboutNewTabService.newTabURL = DOWNLOADS_URL;
   await notificationPromise;
@@ -165,19 +122,18 @@ addTestsWithPrivilegedContentProcessPref
   Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL,
                "Newtab URL defaultURL still set to the default activity stream prerendered URL");
   Assert.ok(aboutNewTabService.overridden, "Newtab URL should be overridden");
   Assert.ok(!aboutNewTabService.activityStreamEnabled, "Activity Stream should not be enabled");
 
   cleanup();
 });
 
-addTestsWithPrivilegedContentProcessPref(async function test_default_url() {
+add_task(async function test_default_url() {
   await setupASPrerendered();
-
   Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_PRERENDER_URL,
     "Newtab defaultURL initially set to prerendered AS url");
 
   // Only debug variants aren't available on release/beta
   if (!IS_RELEASE_OR_BETA) {
     await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_DEBUG_PREF, true,
       "A notification occurs after changing the debug pref to true");
     Assert.equal(aboutNewTabService.activityStreamDebug, true,
@@ -200,17 +156,17 @@ addTestsWithPrivilegedContentProcessPref
   }
 
   Assert.equal(aboutNewTabService.defaultURL, ACTIVITY_STREAM_URL,
     "Newtab defaultURL set to un-prerendered AS if prerender is false and debug is false");
 
   cleanup();
 });
 
-addTestsWithPrivilegedContentProcessPref(async function test_welcome_url() {
+add_task(async function test_welcome_url() {
   await setupASPrerendered();
 
   Assert.equal(aboutNewTabService.activityStreamPrerender, true,
     "Prerendering is enabled by default.");
   Assert.equal(aboutNewTabService.welcomeURL, ACTIVITY_STREAM_URL,
     "Newtab welcomeURL set to un-prerendered AS when prerendering enabled and debug disabled.");
   await setBoolPrefAndWaitForChange(ACTIVITY_STREAM_PRERENDER_PREF, false,
     "A notification occurs after changing the prerender pref to false.");
@@ -233,21 +189,21 @@ addTestsWithPrivilegedContentProcessPref
 });
 
 add_task(function test_locale() {
   Assert.equal(aboutNewTabService.activityStreamLocale, "en-US",
     "The locale for testing should be en-US");
 });
 
 /**
- * Tests response to updates to prefs
+ * Tests reponse to updates to prefs
  */
-addTestsWithPrivilegedContentProcessPref(async function test_updates() {
-  // Simulates a "cold-boot" situation, with some pref already set before testing a series
-  // of changes.
+add_task(async function test_updates() {
+   // Simulates a "cold-boot" situation, with some pref already set before testing a series
+   // of changes.
   await setupASPrerendered();
 
   aboutNewTabService.resetNewTabURL(); // need to set manually because pref notifs are off
   let notificationPromise;
 
   // test update fires on override and reset
   let testURL = "https://example.com/";
   notificationPromise = nextChangeNotificationPromise(
--- a/browser/components/sessionstore/SessionStore.jsm
+++ b/browser/components/sessionstore/SessionStore.jsm
@@ -2431,27 +2431,18 @@ var SessionStoreInternal = {
 
     let tabOptions = {
       userContextId,
       ...(aTab == aWindow.gBrowser.selectedTab ? {relatedToCurrent: true, ownerTab: aTab} : {}),
     };
     let newTab = aWindow.gBrowser.addTrustedTab(null, tabOptions);
 
     // Start the throbber to pretend we're doing something while actually
-    // waiting for data from the frame script. This throbber is disabled
-    // if the URI is a local about: URI.
-    let uriObj = aTab.linkedBrowser.currentURI;
-    if (!uriObj || (uriObj && !aWindow.gBrowser.isLocalAboutURI(uriObj))) {
-      newTab.setAttribute("busy", "true");
-    }
-
-    // Hack to ensure that the about:home, about:newtab, and about:welcome
-    // favicon is loaded instantaneously, to avoid flickering and improve
-    // perceived performance.
-    aWindow.gBrowser.setDefaultIcon(newTab, uriObj);
+    // waiting for data from the frame script.
+    newTab.setAttribute("busy", "true");
 
     // Collect state before flushing.
     let tabState = TabState.collect(aTab, TAB_CUSTOM_VALUES.get(aTab));
 
     // Flush to get the latest tab state to duplicate.
     let browser = aTab.linkedBrowser;
     TabStateFlusher.flush(browser).then(() => {
       // The new tab might have been closed in the meantime.
@@ -2778,24 +2769,17 @@ var SessionStoreInternal = {
         win.gBrowser.setInitialTabTitle(tab, activePageData.title, { isContentTitle: true });
       } else {
         win.gBrowser.setInitialTabTitle(tab, activePageData.url);
       }
     }
 
     // Restore the tab icon.
     if ("image" in tabData) {
-      // We know that about:blank is safe to load in any remote type. Since
-      // SessionStore is triggered with about:blank, there must be a process
-      // flip. We will ignore the first about:blank load to prevent resetting the
-      // favicon that we have set earlier to avoid flickering and improve
-      // perceived performance.
-      if (!activePageData || (activePageData && activePageData.url != "about:blank")) {
-        win.gBrowser.setIcon(tab, tabData.image, undefined, tabData.iconLoadingPrincipal);
-      }
+      win.gBrowser.setIcon(tab, tabData.image, undefined, tabData.iconLoadingPrincipal);
       TabStateCache.update(browser, { image: null, iconLoadingPrincipal: null });
     }
   },
 
   // This method deletes all the closedTabs matching userContextId.
   _forgetTabsWithUserContextId(userContextId) {
     for (let window of Services.wm.getEnumerator("navigator:browser")) {
       let windowState = this._windows[window.__SSi];
@@ -3025,32 +3009,19 @@ var SessionStoreInternal = {
     this._remotenessChangingBrowsers.set(browser.permanentKey, loadArguments);
 
     if (alreadyRestoring) {
       // This tab was already being restored to run in the
       // correct process. We're done here.
       return;
     }
 
-    let uriObj;
-    try {
-      uriObj = Services.io.newURI(loadArguments.uri);
-    } catch (e) {}
-
     // Start the throbber to pretend we're doing something while actually
-    // waiting for data from the frame script. This throbber is disabled
-    // if the URI is a local about: URI.
-    if (!uriObj || (uriObj && !window.gBrowser.isLocalAboutURI(uriObj))) {
-      tab.setAttribute("busy", "true");
-    }
-
-    // Hack to ensure that the about:home, about:newtab, and about:welcome
-    // favicon is loaded instantaneously, to avoid flickering and improve
-    // perceived performance.
-    window.gBrowser.setDefaultIcon(tab, uriObj);
+    // waiting for data from the frame script.
+    tab.setAttribute("busy", "true");
 
     // Flush to get the latest tab state.
     TabStateFlusher.flush(browser).then(() => {
       // loadArguments might have been overwritten by multiple calls
       // to navigateAndRestore while we waited for the tab to flush,
       // so we use the most recently stored one.
       let recentLoadArguments =
         this._remotenessChangingBrowsers.get(browser.permanentKey);
@@ -4066,17 +4037,17 @@ var SessionStoreInternal = {
 
     browser.messageManager.sendAsyncMessage("SessionStore:restoreTabContent",
       {loadArguments, isRemotenessUpdate,
        reason: aOptions.restoreContentReason ||
                RESTORE_TAB_CONTENT_REASON.SET_STATE,
        requestTime: Services.telemetry.msSystemNow()});
 
     // Focus the tab's content area.
-    if (aTab.selected && !window.isBlankPageURL(uri)) {
+    if (aTab.selected) {
       browser.focus();
     }
   },
 
   /**
    * Marks a given pending tab as restoring.
    *
    * @param aTab
--- a/browser/components/uitour/UITour.jsm
+++ b/browser/components/uitour/UITour.jsm
@@ -1360,22 +1360,22 @@ var UITour = {
     } else if (aMenuName == "urlbar") {
       aWindow.gURLBar.closePopup();
     } else if (aMenuName == "pageActionPanel") {
       aWindow.BrowserPageActions.panelNode.hidePopup();
     }
   },
 
   showNewTab(aWindow, aBrowser) {
-    aWindow.gURLBar.focus();
     let url = "about:newtab";
     aWindow.openLinkIn(url, "current", {
       targetBrowser: aBrowser,
       triggeringPrincipal: Services.scriptSecurityManager.createCodebasePrincipal(Services.io.newURI(url), {}),
     });
+    aWindow.gURLBar.focus();
   },
 
   _hideAnnotationsForPanel(aEvent, aShouldClosePanel, aTargetPositionCallback) {
     let win = aEvent.target.ownerGlobal;
     let hideHighlightMethod = null;
     let hideInfoMethod = null;
     if (aShouldClosePanel) {
       hideHighlightMethod = aWin => this.hideHighlight(aWin);
--- a/browser/modules/AsyncTabSwitcher.jsm
+++ b/browser/modules/AsyncTabSwitcher.jsm
@@ -348,17 +348,17 @@ class AsyncTabSwitcher {
       //    tab crashed page yet (in this case, the TabParent is null)
       // 2. The tab has never presented, and has not finished loading
       //    a non-local-about: page.
       //
       // For (2), "finished loading a non-local-about: page" is
       // determined by the busy state on the tab element and checking
       // if the loaded URI is local.
       let hasSufficientlyLoaded = !this.requestedTab.hasAttribute("busy") &&
-        !this.tabbrowser.isLocalAboutURI(requestedBrowser.currentURI);
+        !this.tabbrowser._isLocalAboutURI(requestedBrowser.currentURI);
 
       let fl = requestedBrowser.frameLoader;
       shouldBeBlank = !this.minimizedOrFullyOccluded &&
         (!fl.tabParent ||
           (!hasSufficientlyLoaded && !fl.tabParent.hasPresented));
     }
 
     this.log("Tab should be blank: " + shouldBeBlank);
--- a/devtools/client/responsive.html/browser/swap.js
+++ b/devtools/client/responsive.html/browser/swap.js
@@ -101,42 +101,30 @@ function swapToInnerBrowser({ tab, conta
       browser.loadURI(uri, options);
     });
   }
 
   return {
 
     async start() {
       // In some cases, such as a preloaded browser used for about:newtab, browser code
-      // will force a new frameloader on next navigation to remote content to ensure
-      // balanced process assignment.  If this case will happen here, navigate to
-      // about:blank first to get this out of way so that we stay within one process while
-      // RDM is open. Some process selection rules are specific to remote content, so we
-      // use `http://example.com` as a test for what a remote navigation would cause.
-      const {
-        requiredRemoteType,
-        mustChangeProcess,
-        newFrameloader,
-      } = E10SUtils.shouldLoadURIInBrowser(
-         tab.linkedBrowser,
-        "http://example.com"
+      // will force a new frameloader on next navigation to ensure balanced process
+      // assignment.  If this case will happen here, navigate to about:blank first to get
+      // this out of way so that we stay within one process while RDM is open.
+      const { newFrameloader } = E10SUtils.shouldLoadURIInBrowser(
+        tab.linkedBrowser,
+        "about:blank"
       );
       if (newFrameloader) {
         debug(`Tab will force a new frameloader on navigation, load about:blank first`);
         await loadURIWithNewFrameLoader(tab.linkedBrowser, "about:blank", {
           flags: Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_HISTORY,
           triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal({}),
         });
       }
-      if (mustChangeProcess) {
-        debug(`Tab will force a process flip on navigation, load about:blank first`);
-        gBrowser.updateBrowserRemoteness(tab.linkedBrowser, true, {
-          remoteType: requiredRemoteType,
-        });
-      }
 
       tab.isResponsiveDesignMode = true;
 
       // Hide the browser content temporarily while things move around to avoid displaying
       // strange intermediate states.
       tab.linkedBrowser.style.visibility = "hidden";
 
       // Freeze navigation temporarily to avoid "blinking" in the location bar.
--- a/dom/xhr/tests/browser_xhr_onchange_leak.js
+++ b/dom/xhr/tests/browser_xhr_onchange_leak.js
@@ -6,18 +6,18 @@
 // Bug 1336811 - An XHR that has a .onreadystatechange waiting should
 // not leak forever once the tab is closed. CC optimizations need to be
 // turned off once it is closed.
 
 add_task(async function test() {
   const url = "http://mochi.test:8888/browser/dom/xhr/tests/browser_xhr_onchange_leak.html";
   let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
   let browser = gBrowser.selectedBrowser;
-  let done = await ContentTask.spawn(browser, {}, async function(browser) {
+  let done = await ContentTask.spawn(browser,{}, async function(browser){
     let doc = content.document;
     let promise = ContentTaskUtils.waitForEvent(this, "DOMContentLoaded", true);
-    content.location = "http://example.org/";
+    content.location = "about:home";
     await promise;
     return true;
   });
   is(done, true, "need to check something");
   BrowserTestUtils.removeTab(newTab);
 });
--- a/js/xpconnect/tests/browser/browser_dead_object.js
+++ b/js/xpconnect/tests/browser/browser_dead_object.js
@@ -5,22 +5,22 @@
 
 // For bug 773980, test that Components.utils.isDeadWrapper works as expected.
 
 add_task(async function test() {
   const url = "http://mochi.test:8888/browser/js/xpconnect/tests/browser/browser_deadObjectOnUnload.html";
   let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
   let browser = gBrowser.selectedBrowser;
   let innerWindowId = browser.innerWindowID;
-  let contentDocDead = await ContentTask.spawn(browser, {innerWindowId}, async function(args) {
+  let contentDocDead = await ContentTask.spawn(browser,{innerWindowId}, async function(args){
     let doc = content.document;
     let {TestUtils} = ChromeUtils.import("resource://testing-common/TestUtils.jsm", {});
     let promise = TestUtils.topicObserved("inner-window-nuked", (subject, data) => {
       let id = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
       return id == args.innerWindowId;
     });
-    content.location = "http://example.org/";
+    content.location = "about:home";
     await promise;
     return Cu.isDeadWrapper(doc);
   });
   is(contentDocDead, true, "wrapper is dead");
-  BrowserTestUtils.removeTab(newTab);
+  BrowserTestUtils.removeTab(newTab); 
 });
--- a/testing/mochitest/BrowserTestUtils/BrowserTestUtils.jsm
+++ b/testing/mochitest/BrowserTestUtils/BrowserTestUtils.jsm
@@ -594,18 +594,22 @@ var BrowserTestUtils = {
         }
 
         promises.push(TestUtils.topicObserved("browser-delayed-startup-finished",
                                               subject => subject == win));
 
         if (url) {
           let browser = win.gBrowser.selectedBrowser;
 
+          // Retrieve the given browser's current process type.
+          let process =
+              browser.isRemoteBrowser ? Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT
+              : Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
           if (win.gMultiProcessBrowser &&
-              !E10SUtils.canLoadURIInRemoteType(url, browser.remoteType)) {
+              !E10SUtils.canLoadURIInProcess(url, process)) {
             await this.waitForEvent(browser, "XULFrameLoaderCreated");
           }
 
           let loadPromise = this.browserLoaded(browser, false, url, maybeErrorPage);
           promises.push(loadPromise);
         }
 
         await Promise.all(promises);
@@ -638,20 +642,24 @@ var BrowserTestUtils = {
       triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
     });
 
     // Nothing to do in non-e10s mode.
     if (!browser.ownerGlobal.gMultiProcessBrowser) {
       return;
     }
 
+    // Retrieve the given browser's current process type.
+    let process = browser.isRemoteBrowser ? Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT
+                                          : Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+
     // If the new URI can't load in the browser's current process then we
     // should wait for the new frameLoader to be created. This will happen
     // asynchronously when the browser's remoteness changes.
-    if (!E10SUtils.canLoadURIInRemoteType(uri, browser.remoteType)) {
+    if (!E10SUtils.canLoadURIInProcess(uri, process)) {
       await this.waitForEvent(browser, "XULFrameLoaderCreated");
     }
   },
 
   /**
    * @param win (optional)
    *        The window we should wait to have "domwindowopened" sent through
    *        the observer service for. If this is not supplied, we'll just
deleted file mode 100644
--- a/testing/web-platform/meta/fetch/api/request/destination/fetch-destination.https.html.ini
+++ /dev/null
@@ -1,6 +0,0 @@
-[fetch-destination.https.html]
-  prefs: [browser.tabs.remote.separatePrivilegedContentProcess:true]
-  expected: TIMEOUT
-
-  [HTMLLinkElement with rel=prefetch fetches with an empty string Request.destination]
-    expected: TIMEOUT
--- a/toolkit/content/tests/browser/browser_findbar.js
+++ b/toolkit/content/tests/browser/browser_findbar.js
@@ -1,13 +1,13 @@
 /* eslint-disable mozilla/no-arbitrary-setTimeout */
 ChromeUtils.import("resource://gre/modules/Timer.jsm", this);
 
 const TEST_PAGE_URI = "data:text/html;charset=utf-8,The letter s.";
-// Using 'javascript' schema to bypass E10SUtils.canLoadURIInRemoteType, because
+// Using 'javascript' schema to bypass E10SUtils.canLoadURIInProcess, because
 // it does not allow 'data:' URI to be loaded in the parent process.
 const E10S_PARENT_TEST_PAGE_URI = "javascript:document.write('The letter s.');";
 
 /**
  * Makes sure that the findbar hotkeys (' and /) event listeners
  * are added to the system event group and do not get blocked
  * by calling stopPropagation on a keypress event on a page.
  */
--- a/toolkit/modules/E10SUtils.jsm
+++ b/toolkit/modules/E10SUtils.jsm
@@ -85,24 +85,20 @@ var E10SUtils = {
   DEFAULT_REMOTE_TYPE,
   NOT_REMOTE,
   WEB_REMOTE_TYPE,
   FILE_REMOTE_TYPE,
   EXTENSION_REMOTE_TYPE,
   PRIVILEGED_REMOTE_TYPE,
   LARGE_ALLOCATION_REMOTE_TYPE,
 
-  canLoadURIInRemoteType(aURL, aRemoteType = DEFAULT_REMOTE_TYPE) {
-    // We need a strict equality here because the value of `NOT_REMOTE` is
-    // `null`, and there is a possibility that `undefined` is passed as the
-    // second argument, which might result a load in the parent process.
-    let preferredRemoteType = aRemoteType === NOT_REMOTE
-      ? NOT_REMOTE
-      : DEFAULT_REMOTE_TYPE;
-    return aRemoteType == this.getRemoteTypeForURI(aURL, true, preferredRemoteType);
+  canLoadURIInProcess(aURL, aProcess) {
+    let remoteType = aProcess == Ci.nsIXULRuntime.PROCESS_TYPE_CONTENT
+                     ? DEFAULT_REMOTE_TYPE : NOT_REMOTE;
+    return remoteType == this.getRemoteTypeForURI(aURL, true, remoteType);
   },
 
   getRemoteTypeForURI(aURL, aMultiProcess,
                       aPreferredRemoteType = DEFAULT_REMOTE_TYPE,
                       aCurrentUri) {
     if (!aMultiProcess) {
       return NOT_REMOTE;
     }
--- a/toolkit/mozapps/extensions/content/extensions.js
+++ b/toolkit/mozapps/extensions/content/extensions.js
@@ -3076,19 +3076,20 @@ var gDetailView = {
       event.stopPropagation();
     });
 
     let {optionsURL, optionsBrowserStyle} = this._addon;
     if (this._addon.isWebExtension) {
       let policy = ExtensionParent.WebExtensionPolicy.getByID(this._addon.id);
       browser.sameProcessAsFrameLoader = policy.extension.groupFrameLoader;
     }
+    let remote = !E10SUtils.canLoadURIInProcess(optionsURL, Services.appinfo.PROCESS_TYPE_DEFAULT);
 
     let readyPromise;
-    if (E10SUtils.canLoadURIInRemoteType(optionsURL, E10SUtils.EXTENSION_REMOTE_TYPE)) {
+    if (remote) {
       browser.setAttribute("remote", "true");
       browser.setAttribute("remoteType", E10SUtils.EXTENSION_REMOTE_TYPE);
       readyPromise = promiseEvent("XULFrameLoaderCreated", browser);
     } else {
       readyPromise = promiseEvent("load", browser, true);
     }
 
     stack.appendChild(browser);