Bug 1539595 - Rename Priveleged Content Process to PrivlegedAbout Content Process r=mconley,flod
authorTom Ritter <tom@mozilla.com>
Wed, 29 May 2019 11:31:31 +0000
changeset 476047 7f30c1db8835cf11237b51835ca26522f8d0c06d
parent 476046 0553541318c4d5b7aba2a9b195470db9dc5c782e
child 476048 d97e735a0ee9e6c4e3f39b445d2653c766290826
push id36083
push usernerli@mozilla.com
push dateWed, 29 May 2019 15:58:28 +0000
treeherdermozilla-central@2bb77ed1fcc5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmconley, flod
bugs1539595
milestone69.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1539595 - Rename Priveleged Content Process to PrivlegedAbout Content Process r=mconley,flod We do this because we will be introducing more privileged content processes and we want to be able to distinguish them. Differential Revision: https://phabricator.services.mozilla.com/D30274
browser/app/profile/firefox.js
browser/base/content/test/general/browser_e10s_about_process.js
browser/base/content/test/tabs/browser.ini
browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
browser/base/content/test/tabs/browser_new_tab_in_privilegedabout_process_pref.js
browser/components/about/AboutRedirector.cpp
browser/components/aboutlogins/AboutLoginsParent.jsm
browser/components/newtab/AboutNewTabService.jsm
browser/components/tests/browser/browser_initial_tab_remoteType.js
devtools/client/responsive.html/browser/swap.js
docshell/base/nsAboutRedirector.cpp
dom/base/ChromeUtils.cpp
dom/chrome-webidl/ChromeUtils.webidl
dom/ipc/ContentChild.cpp
dom/ipc/ContentParent.h
dom/ipc/tests/JSWindowActor/browser_getActor_filter.js
js/xpconnect/loader/ScriptPreloader.cpp
js/xpconnect/loader/ScriptPreloader.h
modules/libpref/init/all.js
netwerk/protocol/about/nsIAboutModule.idl
toolkit/locales/en-US/toolkit/global/processTypes.ftl
toolkit/modules/E10SUtils.jsm
widget/ProcInfo.h
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -493,17 +493,19 @@ 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.
+// Pref to control whether we use a separate privileged content process
+// for about: pages. This pref name did not age well: we will have multiple
+// types of privileged content processes, each with different privileges.
 #if defined(NIGHTLY_BUILD) && !defined(MOZ_ASAN)
 pref("browser.tabs.remote.separatePrivilegedContentProcess", true);
 #endif
 
 #ifdef NIGHTLY_BUILD
 pref("browser.tabs.remote.useHTTPResponseProcessSelection", true);
 #else
 // Disabled outside of nightly due to bug 1554217
--- a/browser/base/content/test/general/browser_e10s_about_process.js
+++ b/browser/base/content/test/general/browser_e10s_about_process.js
@@ -1,11 +1,11 @@
 const CHROME_PROCESS = E10SUtils.NOT_REMOTE;
 const WEB_CONTENT_PROCESS = E10SUtils.WEB_REMOTE_TYPE;
-const PRIVILEGED_CONTENT_PROCESS = E10SUtils.PRIVILEGED_REMOTE_TYPE;
+const PRIVILEGED_CONTENT_PROCESS = E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE;
 const EXTENSION_PROCESS = E10SUtils.EXTENSION_REMOTE_TYPE;
 
 const CHROME = {
   id: "cb34538a-d9da-40f3-b61a-069f0b2cb9fb",
   path: "test-chrome",
   flags: 0,
 };
 const CANREMOTE = {
@@ -17,17 +17,17 @@ 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,
+         Ci.nsIAboutModule.URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS,
 };
 const MUSTEXTENSION = {
   id: "f7a1798f-965b-49e9-be83-ec6ee4d7d675",
   path: "test-mustextension",
   flags: Ci.nsIAboutModule.URI_MUST_LOAD_IN_EXTENSION_PROCESS,
 };
 
 
@@ -147,30 +147,30 @@ add_task(async function test_remote() {
 
 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
+  // This shouldn't be taken literally. We will always use the privleged about
+  // content type if the URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS flag is enabled and
   // the pref is turned on.
   test_url("about:" + CANPRIVILEGEDREMOTE.path, false, false, true, false);
 });
 
 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
+  // This shouldn't be taken literally. We will always use the privleged about
+  // content type if the URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS flag is enabled and
   // the pref is turned on.
   test_url("about:" + CANPRIVILEGEDREMOTE.path, false, true, false, false);
 });
 
 add_task(async function test_extension() {
   test_url("about:" + MUSTEXTENSION.path, false, false, false, true);
 });
--- a/browser/base/content/test/tabs/browser.ini
+++ b/browser/base/content/test/tabs/browser.ini
@@ -47,17 +47,17 @@ skip-if = os == 'mac' # Skipped because 
 [browser_multiselect_tabs_using_Shift_and_Ctrl.js]
 [browser_multiselect_tabs_using_Shift.js]
 [browser_navigatePinnedTab.js]
 [browser_new_file_whitelisted_http_tab.js]
 skip-if = !e10s # Test only relevant for e10s.
 [browser_new_tab_insert_position.js]
 skip-if = (debug && os == 'linux' && bits == 32) #Bug 1455882, disabled on Linux32 for almost permafailing
 support-files = file_new_tab_page.html
-[browser_new_tab_in_privileged_process_pref.js]
+[browser_new_tab_in_privilegedabout_process_pref.js]
 skip-if = !e10s # Pref and test only relevant for e10s.
 [browser_new_web_tab_in_file_process_pref.js]
 skip-if = !e10s # Pref and test only relevant for e10s.
 [browser_newwindow_tabstrip_overflow.js]
 [browser_open_newtab_start_observer_notification.js]
 [browser_opened_file_tab_navigated_to_web.js]
 [browser_overflowScroll.js]
 [browser_paste_event_at_middle_click_on_link.js]
rename from browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
rename to browser/base/content/test/tabs/browser_new_tab_in_privilegedabout_process_pref.js
--- a/browser/base/content/test/tabs/browser_new_tab_in_privileged_process_pref.js
+++ b/browser/base/content/test/tabs/browser_new_tab_in_privilegedabout_process_pref.js
@@ -1,17 +1,18 @@
 /* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 /**
- * Tests to ensure that Activity Stream loads in the privileged content process.
- * Normal http web pages should load in the web content process.
+ * Tests to ensure that Activity Stream loads in the privileged about:
+ * content process. Normal http web pages should load in the web content
+ * process.
  * Ref: Bug 1469072.
  */
 
 const ABOUT_BLANK = "about:blank";
 const ABOUT_HOME = "about:home";
 const ABOUT_NEWTAB = "about:newtab";
 const ABOUT_WELCOME = "about:welcome";
 const TEST_HTTP = "http://example.org/";
@@ -41,34 +42,34 @@ function checkBrowserRemoteType(
     "Parent and child process should agree on the remote type.");
 }
 
 add_task(async function setup() {
   await SpecialPowers.pushPrefEnv({
     set: [
       ["browser.newtab.preload", false],
       ["browser.tabs.remote.separatePrivilegedContentProcess", true],
-      ["dom.ipc.processCount.privileged", 1],
-      ["dom.ipc.keepProcessesAlive.privileged", 1],
+      ["dom.ipc.processCount.privilegedabout", 1],
+      ["dom.ipc.keepProcessesAlive.privilegedabout", 1],
     ],
   });
 });
 
 /*
- * Test to ensure that the Activity Stream tabs open in privileged content
+ * Test to ensure that the Activity Stream tabs open in privileged about: content
  * process. We will first open an about:newtab page that acts as a reference to
- * 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.
+ * the privileged about:  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 about: 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);
+    checkBrowserRemoteType(browser1, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
     let privilegedPid = browser1.frameLoader.remoteTab.osPid;
 
     for (let url of [
       ABOUT_NEWTAB,
       ABOUT_WELCOME,
       ABOUT_HOME,
@@ -76,17 +77,17 @@ add_task(async function activity_stream_
       `${ABOUT_WELCOME}#bar`,
       `${ABOUT_HOME}#baz`,
       `${ABOUT_NEWTAB}?q=foo`,
       `${ABOUT_WELCOME}?q=bar`,
       `${ABOUT_HOME}?q=baz`,
     ]) {
       await BrowserTestUtils.withNewTab(url, async function(browser2) {
         is(browser2.frameLoader.remoteTab.osPid, privilegedPid,
-          "Check that about:newtab tabs are in the same privileged content process.");
+          "Check that about:newtab tabs are in the same privileged about: content process.");
       });
     }
   });
 
   Services.ppmm.releaseCachedProcesses();
 });
 
 /*
@@ -95,35 +96,35 @@ add_task(async function activity_stream_
  */
 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);
 
     for (let [url, remoteType] of [
-      [ABOUT_NEWTAB, E10SUtils.PRIVILEGED_REMOTE_TYPE],
-      [ABOUT_BLANK, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [ABOUT_NEWTAB, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
+      [ABOUT_BLANK, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [ABOUT_HOME, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [ABOUT_HOME, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [ABOUT_WELCOME, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [ABOUT_WELCOME, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
       [ABOUT_BLANK, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_NEWTAB}#foo`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_NEWTAB}#foo`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_WELCOME}#bar`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_WELCOME}#bar`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_HOME}#baz`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_HOME}#baz`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_NEWTAB}?q=foo`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_NEWTAB}?q=foo`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_WELCOME}?q=bar`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_WELCOME}?q=bar`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
-      [`${ABOUT_HOME}?q=baz`, E10SUtils.PRIVILEGED_REMOTE_TYPE],
+      [`${ABOUT_HOME}?q=baz`, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE],
       [TEST_HTTP, E10SUtils.WEB_REMOTE_TYPE],
     ]) {
       BrowserTestUtils.loadURI(browser, url);
       await BrowserTestUtils.browserLoaded(browser, false, url);
       checkBrowserRemoteType(browser, remoteType);
     }
   });
 
@@ -134,79 +135,79 @@ add_task(async function process_switchin
  * 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);
+    checkBrowserRemoteType(browser, E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE);
 
     // Note the processID for about:newtab for comparison later.
     let privilegedPid = browser.frameLoader.remoteTab.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");
     });
     let newTab = await promiseTabOpened;
     registerCleanupFunction(async function() {
       BrowserTestUtils.removeTab(newTab);
     });
     browser = newTab.linkedBrowser;
     is(browser.frameLoader.remoteTab.osPid, privilegedPid,
-      "Check that new tab opened from about:newtab is loaded in privileged content process.");
+      "Check that new tab opened from about:newtab is loaded in privileged about: content process.");
 
-    // Check that reload does not break the privileged content process affinity.
+    // Check that reload does not break the privileged about: content process affinity.
     BrowserReload();
     await BrowserTestUtils.browserLoaded(browser, false, ABOUT_NEWTAB);
     is(browser.frameLoader.remoteTab.osPid, privilegedPid,
-      "Check that about:newtab is still in privileged content process after reload.");
+      "Check that about:newtab is still in privileged about: 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);
 
-    // Check that using the history back feature switches back to privileged content process.
+    // Check that using the history back feature switches back to privileged about: 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");
     is(browser.frameLoader.remoteTab.osPid, privilegedPid,
-      "Check that about:newtab is still in privileged content process after history goBack.");
+      "Check that about:newtab is still in privileged about: content process after history goBack.");
 
     // 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,
       "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.remoteTab.osPid, privilegedPid,
-      "Check that about:newtab is in privileged content process after history gotoIndex.");
+      "Check that about:newtab is in privileged about: content process after history gotoIndex.");
 
     BrowserTestUtils.loadURI(browser, TEST_HTTP);
     await BrowserTestUtils.browserLoaded(browser, false, TEST_HTTP);
     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.remoteTab.osPid, privilegedPid,
-      "Check that about:newtab is in privileged content process after location change.");
+      "Check that about:newtab is in privileged about: content process after location change.");
   });
 
   Services.ppmm.releaseCachedProcesses();
 });
--- a/browser/components/about/AboutRedirector.cpp
+++ b/browser/components/about/AboutRedirector.cpp
@@ -22,17 +22,17 @@ namespace browser {
 NS_IMPL_ISUPPORTS(AboutRedirector, nsIAboutModule)
 
 bool AboutRedirector::sNewTabPageEnabled = false;
 bool AboutRedirector::sAboutLoginsEnabled = false;
 
 static const uint32_t ACTIVITY_STREAM_FLAGS =
     nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::ENABLE_INDEXED_DB |
     nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
-    nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGED_CHILD |
+    nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS |
     nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT;
 
 struct RedirEntry {
   const char* id;
   const char* url;
   uint32_t flags;
 };
 
@@ -54,17 +54,17 @@ static const RedirEntry kRedirMap[] = {
          nsIAboutModule::URI_CAN_LOAD_IN_CHILD | nsIAboutModule::ALLOW_SCRIPT |
          nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"config", "chrome://browser/content/aboutconfig/aboutconfig.html", 0},
     {"framecrashed", "chrome://browser/content/aboutFrameCrashed.html",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"logins", "chrome://browser/content/aboutlogins/aboutLogins.html",
      nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
-         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGED_CHILD |
+         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS |
          nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT},
     {"tabcrashed", "chrome://browser/content/aboutTabCrashed.xhtml",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"policies", "chrome://browser/content/policies/aboutPolicies.xhtml",
      nsIAboutModule::ALLOW_SCRIPT},
     {"privatebrowsing", "chrome://browser/content/aboutPrivateBrowsing.xhtml",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
@@ -80,17 +80,17 @@ static const RedirEntry kRedirMap[] = {
     {"welcomeback", "chrome://browser/content/aboutWelcomeBack.xhtml",
      nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     // Actual activity stream URL for home and newtab are set in channel
     // creation
     {"home", "about:blank", ACTIVITY_STREAM_FLAGS},
     {"newtab", "about:blank", ACTIVITY_STREAM_FLAGS},
     {"welcome", "about:blank",
      nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
-         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGED_CHILD |
+         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS |
          nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::ALLOW_SCRIPT},
     {"library", "chrome://browser/content/aboutLibrary.xhtml",
      nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
          nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT},
     {"pocket-saved", "chrome://pocket/content/panels/saved.html",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::URI_CAN_LOAD_IN_CHILD | nsIAboutModule::ALLOW_SCRIPT |
@@ -113,17 +113,17 @@ static const RedirEntry kRedirMap[] = {
      nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"newinstall", "chrome://browser/content/newInstallPage.html",
      nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
          nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::ALLOW_SCRIPT | nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"protections", "chrome://browser/content/protections.html",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::URI_MUST_LOAD_IN_CHILD | nsIAboutModule::ALLOW_SCRIPT |
-         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGED_CHILD},
+         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS},
 };
 
 static nsAutoCString GetAboutModuleName(nsIURI* aURI) {
   nsAutoCString path;
   aURI->GetPathQueryRef(path);
 
   int32_t f = path.FindChar('#');
   if (f >= 0) path.SetLength(f);
--- a/browser/components/aboutlogins/AboutLoginsParent.jsm
+++ b/browser/components/aboutlogins/AboutLoginsParent.jsm
@@ -18,26 +18,26 @@ ChromeUtils.defineModuleGetter(this, "Se
 
 XPCOMUtils.defineLazyGetter(this, "log", () => {
   return LoginHelper.createLogger("AboutLoginsParent");
 });
 
 const ABOUT_LOGINS_ORIGIN = "about:logins";
 const MASTER_PASSWORD_NOTIFICATION_ID = "master-password-login-required";
 
-const PRIVILEGED_PROCESS_PREF =
+const PRIVILEGEDABOUT_PROCESS_PREF =
   "browser.tabs.remote.separatePrivilegedContentProcess";
-const PRIVILEGED_PROCESS_ENABLED =
-  Services.prefs.getBoolPref(PRIVILEGED_PROCESS_PREF, false);
+const PRIVILEGEDABOUT_PROCESS_ENABLED =
+  Services.prefs.getBoolPref(PRIVILEGEDABOUT_PROCESS_PREF, false);
 
 // When the privileged content process is enabled, we expect about:logins
 // to load in it. Otherwise, it's in a normal web content process.
 const EXPECTED_ABOUTLOGINS_REMOTE_TYPE =
-  PRIVILEGED_PROCESS_ENABLED ? E10SUtils.PRIVILEGED_REMOTE_TYPE
-                             : E10SUtils.DEFAULT_REMOTE_TYPE;
+  PRIVILEGEDABOUT_PROCESS_ENABLED ? E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE
+                                  : E10SUtils.DEFAULT_REMOTE_TYPE;
 
 const isValidLogin = login => {
   return !(login.hostname || "").startsWith("chrome://");
 };
 
 const convertSubjectToLogin = subject => {
   subject.QueryInterface(Ci.nsILoginMetaInfo).QueryInterface(Ci.nsILoginInfo);
   const login = LoginHelper.loginToVanillaObject(subject);
--- a/browser/components/newtab/AboutNewTabService.jsm
+++ b/browser/components/newtab/AboutNewTabService.jsm
@@ -21,28 +21,28 @@ const TOPIC_CONTENT_DOCUMENT_INTERACTIVE
 // https://github.com/mozilla/activity-stream/blob/master/bin/render-activity-stream-html.js
 const ACTIVITY_STREAM_BCP47 = "en-US ach an ar ast az be bg bn br bs ca cak crh cs cy da de dsb el en-CA en-GB eo es-AR es-CL es-ES es-MX et eu fa ff fi fr fy-NL ga-IE gd gl gn gu-IN he hi-IN hr hsb hu hy-AM ia id is it ja ja-JP-macos ka kab kk km kn ko lij lo lt ltg lv mk mr ms my nb-NO ne-NP nl nn-NO oc pa-IN pl pt-BR pt-PT rm ro ru si sk sl sq sr sv-SE ta te th tl tr trs uk ur uz vi zh-CN zh-TW".split(" ");
 
 const ABOUT_URL = "about:newtab";
 const BASE_URL = "resource://activity-stream/";
 const ACTIVITY_STREAM_PAGES = new Set(["home", "newtab", "welcome"]);
 
 const IS_MAIN_PROCESS = Services.appinfo.processType === Services.appinfo.PROCESS_TYPE_DEFAULT;
-const IS_PRIVILEGED_PROCESS = Services.appinfo.remoteType === E10SUtils.PRIVILEGED_REMOTE_TYPE;
+const IS_PRIVILEGED_PROCESS = Services.appinfo.remoteType === E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE;
 
 const IS_RELEASE_OR_BETA = AppConstants.RELEASE_OR_BETA;
 
-const PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS = "browser.tabs.remote.separatePrivilegedContentProcess";
+const PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS = "browser.tabs.remote.separatePrivilegedContentProcess";
 const PREF_ACTIVITY_STREAM_PRERENDER_ENABLED = "browser.newtabpage.activity-stream.prerender";
 const PREF_ACTIVITY_STREAM_DEBUG = "browser.newtabpage.activity-stream.debug";
 
 function AboutNewTabService() {
   Services.obs.addObserver(this, TOPIC_APP_QUIT);
   Services.obs.addObserver(this, TOPIC_LOCALES_CHANGE);
-  Services.prefs.addObserver(PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS, this);
+  Services.prefs.addObserver(PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS, this);
   Services.prefs.addObserver(PREF_ACTIVITY_STREAM_PRERENDER_ENABLED, this);
   if (!IS_RELEASE_OR_BETA) {
     Services.prefs.addObserver(PREF_ACTIVITY_STREAM_DEBUG, this);
   }
 
   // More initialization happens here
   this.toggleActivityStream(true);
   this.initialized = true;
@@ -88,31 +88,31 @@ function AboutNewTabService() {
  */
 AboutNewTabService.prototype = {
 
   _newTabURL: ABOUT_URL,
   _activityStreamEnabled: false,
   _activityStreamPrerender: false,
   _activityStreamPath: "",
   _activityStreamDebug: false,
-  _privilegedContentProcess: false,
+  _privilegedAboutContentProcess: false,
   _overridden: false,
   willNotifyUser: false,
 
   classID: Components.ID("{dfcd2adc-7867-4d3a-ba70-17501f208142}"),
   QueryInterface: ChromeUtils.generateQI([
     Ci.nsIAboutNewTabService,
     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);
+        if (data === PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS) {
+          this._privilegedAboutContentProcess = Services.prefs.getBoolPref(PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS);
           this.updatePrerenderedPath();
           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();
@@ -211,34 +211,34 @@ AboutNewTabService.prototype = {
       // exit there is no change of state
       return false;
     }
     if (stateEnabled) {
       this._activityStreamEnabled = true;
     } else {
       this._activityStreamEnabled = false;
     }
-    this._privilegedContentProcess = Services.prefs.getBoolPref(PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS);
+    this._privilegedAboutContentProcess = Services.prefs.getBoolPref(PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS);
     this._activityStreamPrerender = Services.prefs.getBoolPref(PREF_ACTIVITY_STREAM_PRERENDER_ENABLED);
     if (!IS_RELEASE_OR_BETA) {
       this._activityStreamDebug = Services.prefs.getBoolPref(PREF_ACTIVITY_STREAM_DEBUG, false);
     }
     this.updatePrerenderedPath();
     this._newtabURL = ABOUT_URL;
     return true;
   },
 
   /**
    * Figure out what path under prerendered to use based on current state.
    */
   updatePrerenderedPath() {
     // Debug files are specially packaged in a non-localized directory, but with
     // dynamic script loading, localized debug is supported.
     this._activityStreamPath = `${this._activityStreamDebug &&
-      !this._privilegedContentProcess ? "static" : this.activityStreamLocale}/`;
+      !this._privilegedAboutContentProcess ? "static" : this.activityStreamLocale}/`;
   },
 
   /*
    * Returns the default URL.
    *
    * This URL depends on various activity stream prefs and locales. Overriding
    * the newtab page has no effect on the result of this function.
    */
@@ -248,18 +248,18 @@ AboutNewTabService.prototype = {
     // resource://activity-stream/prerendered/en-US/activity-stream-prerendered.html
     // resource://activity-stream/prerendered/static/activity-stream-debug.html
     return [
       "resource://activity-stream/prerendered/",
       this._activityStreamPath,
       "activity-stream",
       this._activityStreamPrerender ? "-prerendered" : "",
       // Debug version loads dev scripts but noscripts separately loads scripts
-      this._activityStreamDebug && !this._privilegedContentProcess ? "-debug" : "",
-      this._privilegedContentProcess ? "-noscripts" : "",
+      this._activityStreamDebug && !this._privilegedAboutContentProcess ? "-debug" : "",
+      this._privilegedAboutContentProcess ? "-noscripts" : "",
       ".html",
     ].join("");
   },
 
   /*
    * Returns the about:welcome URL
    *
    * This is calculated in the same way the default URL is, except that we don't
@@ -346,17 +346,17 @@ AboutNewTabService.prototype = {
   },
 
   uninit() {
     if (!this.initialized) {
       return;
     }
     Services.obs.removeObserver(this, TOPIC_APP_QUIT);
     Services.obs.removeObserver(this, TOPIC_LOCALES_CHANGE);
-    Services.prefs.removeObserver(PREF_SEPARATE_PRIVILEGED_CONTENT_PROCESS, this);
+    Services.prefs.removeObserver(PREF_SEPARATE_PRIVILEGEDABOUT_CONTENT_PROCESS, this);
     Services.prefs.removeObserver(PREF_ACTIVITY_STREAM_PRERENDER_ENABLED, this);
     if (!IS_RELEASE_OR_BETA) {
       Services.prefs.removeObserver(PREF_ACTIVITY_STREAM_DEBUG, this);
     }
     this.initialized = false;
   },
 };
 
--- a/browser/components/tests/browser/browser_initial_tab_remoteType.js
+++ b/browser/components/tests/browser/browser_initial_tab_remoteType.js
@@ -4,27 +4,27 @@
 /**
  * These tests test that the initial browser tab has the right
  * process type assigned to it on creation, which avoids needless
  * process flips.
  */
 
 "use strict";
 
-const PRIVILEGED_PROCESS_PREF =
+const PRIVILEGEDABOUT_PROCESS_PREF =
   "browser.tabs.remote.separatePrivilegedContentProcess";
-const PRIVILEGED_PROCESS_ENABLED =
-  Services.prefs.getBoolPref(PRIVILEGED_PROCESS_PREF);
+const PRIVILEGEDABOUT_PROCESS_ENABLED =
+  Services.prefs.getBoolPref(PRIVILEGEDABOUT_PROCESS_PREF);
 
 const REMOTE_BROWSER_SHOWN = "remote-browser-shown";
 
 // When the privileged content process is enabled, we expect about:home
 // to load in it. Otherwise, it's in a normal web content process.
 const EXPECTED_ABOUTHOME_REMOTE_TYPE =
-  PRIVILEGED_PROCESS_ENABLED ? E10SUtils.PRIVILEGED_REMOTE_TYPE
+  PRIVILEGEDABOUT_PROCESS_ENABLED ? E10SUtils.PRIVILEGEDABOUT_REMOTE_TYPE
                              : E10SUtils.DEFAULT_REMOTE_TYPE;
 
 /**
  * Test helper function that takes an nsICommandLine, and passes it
  * into the default command line handler for the browser. It expects
  * a new browser window to open, and then checks that the expected page
  * loads in the initial tab in the expected remote type, without doing
  * unnecessary process flips. The helper function then closes the window.
--- a/devtools/client/responsive.html/browser/swap.js
+++ b/devtools/client/responsive.html/browser/swap.js
@@ -136,17 +136,17 @@ function swapToInnerBrowser({ tab, conta
       // The other trade is that sometimes users will be viewing the local file
       // URI process, and will want to view the page in RDM. We allow this without
       // blanking out the page, but we trade that for closing RDM if browsing ever
       // causes them to flip processes.
       //
       // Bug 1510806 has been filed to fix this properly, by making RDM resilient
       // to process flips.
       if (mustChangeProcess &&
-          tab.linkedBrowser.remoteType == "privileged") {
+          tab.linkedBrowser.remoteType == "privilegedabout") {
         debug(`Tab must flip away from the privileged content process ` +
               `on navigation`);
         gBrowser.updateBrowserRemoteness(tab.linkedBrowser, {
           remoteType: requiredRemoteType,
         });
       }
 
       tab.isResponsiveDesignMode = true;
--- a/docshell/base/nsAboutRedirector.cpp
+++ b/docshell/base/nsAboutRedirector.cpp
@@ -86,17 +86,17 @@ static const RedirEntry kRedirMap[] = {
          // Linkable for testing reasons.
          nsIAboutModule::MAKE_LINKABLE},
     {"memory", "chrome://global/content/aboutMemory.xhtml",
      nsIAboutModule::ALLOW_SCRIPT},
     {"certificate", "chrome://global/content/certviewer/certviewer.html",
      nsIAboutModule::ALLOW_SCRIPT |
          nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::URI_MUST_LOAD_IN_CHILD |
-         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGED_CHILD},
+         nsIAboutModule::URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS},
     {"mozilla", "chrome://global/content/mozilla.xhtml",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT},
     {"neterror", "chrome://global/content/netError.xhtml",
      nsIAboutModule::URI_SAFE_FOR_UNTRUSTED_CONTENT |
          nsIAboutModule::URI_CAN_LOAD_IN_CHILD | nsIAboutModule::ALLOW_SCRIPT |
          nsIAboutModule::HIDE_FROM_ABOUTABOUT},
     {"networking", "chrome://global/content/aboutNetworking.xhtml",
      nsIAboutModule::ALLOW_SCRIPT},
--- a/dom/base/ChromeUtils.cpp
+++ b/dom/base/ChromeUtils.cpp
@@ -705,18 +705,19 @@ already_AddRefed<Promise> ChromeUtils::R
               processType.Assign(contentParent->GetRemoteType());
               mozilla::ProcType type = mozilla::ProcType::Unknown;
               if (processType.EqualsLiteral(DEFAULT_REMOTE_TYPE)) {
                 type = mozilla::ProcType::Web;
               } else if (processType.EqualsLiteral(FILE_REMOTE_TYPE)) {
                 type = mozilla::ProcType::File;
               } else if (processType.EqualsLiteral(EXTENSION_REMOTE_TYPE)) {
                 type = mozilla::ProcType::Extension;
-              } else if (processType.EqualsLiteral(PRIVILEGED_REMOTE_TYPE)) {
-                type = mozilla::ProcType::Privileged;
+              } else if (processType.EqualsLiteral(
+                             PRIVILEGEDABOUT_REMOTE_TYPE)) {
+                type = mozilla::ProcType::PrivilegedAbout;
               } else if (processType.EqualsLiteral(
                              LARGE_ALLOCATION_REMOTE_TYPE)) {
                 type = mozilla::ProcType::WebLargeAllocation;
               }
 
               promises.AppendElement(mozilla::GetProcInfo(
                   (base::ProcessId)childPid, contentParent->ChildID(), type));
             }
--- a/dom/chrome-webidl/ChromeUtils.webidl
+++ b/dom/chrome-webidl/ChromeUtils.webidl
@@ -410,17 +410,17 @@ partial namespace ChromeUtils {
  * Holds information about Firefox running processes & threads.
  *
  * See widget/ProcInfo.h for fields documentation.
  */
 enum ProcType {
  "web",
  "file",
  "extension",
- "privileged",
+ "privilegedabout",
  "webLargeAllocation",
  "gpu",
  "rdd",
  "socket",
  "browser",
  "unknown"
 };
 
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -2723,17 +2723,17 @@ mozilla::ipc::IPCResult ContentChild::Re
   mRemoteType.Assign(aRemoteType);
 
   // For non-default ("web") types, update the process name so about:memory's
   // process names are more obvious.
   if (aRemoteType.EqualsLiteral(FILE_REMOTE_TYPE)) {
     SetProcessName(NS_LITERAL_STRING("file:// Content"));
   } else if (aRemoteType.EqualsLiteral(EXTENSION_REMOTE_TYPE)) {
     SetProcessName(NS_LITERAL_STRING("WebExtensions"));
-  } else if (aRemoteType.EqualsLiteral(PRIVILEGED_REMOTE_TYPE)) {
+  } else if (aRemoteType.EqualsLiteral(PRIVILEGEDABOUT_REMOTE_TYPE)) {
     SetProcessName(NS_LITERAL_STRING("Privileged Content"));
   } else if (aRemoteType.EqualsLiteral(LARGE_ALLOCATION_REMOTE_TYPE)) {
     SetProcessName(NS_LITERAL_STRING("Large Allocation Web Content"));
   }
 
   return IPC_OK();
 }
 
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -47,17 +47,17 @@
 
 // These must match the similar ones in E10SUtils.jsm and ProcInfo.h.
 // Process names as reported by about:memory are defined in
 // ContentChild:RecvRemoteType.  Add your value there too or it will be called
 // "Web Content".
 #define DEFAULT_REMOTE_TYPE "web"
 #define FILE_REMOTE_TYPE "file"
 #define EXTENSION_REMOTE_TYPE "extension"
-#define PRIVILEGED_REMOTE_TYPE "privileged"
+#define PRIVILEGEDABOUT_REMOTE_TYPE "privilegedabout"
 
 // This must start with the DEFAULT_REMOTE_TYPE above.
 #define LARGE_ALLOCATION_REMOTE_TYPE "webLargeAllocation"
 
 class nsConsoleService;
 class nsIContentProcessInfo;
 class nsICycleCollectorLogSink;
 class nsIDumpGCAndCCLogsCallback;
--- a/dom/ipc/tests/JSWindowActor/browser_getActor_filter.js
+++ b/dom/ipc/tests/JSWindowActor/browser_getActor_filter.js
@@ -87,17 +87,17 @@ declTest("getActor with remoteType match
       let child = content.window.getWindowGlobalChild();
       ok(child, "WindowGlobalChild should have value.");
       ok(child.getActor("Test"), "JSWindowActorChild should have value.");
     });
   },
 });
 
 declTest("getActor with remoteType mismatch", {
-  remoteTypes: ["privileged"],
+  remoteTypes: ["privilegedabout"],
   url: TEST_URL,
 
   async test(browser) {
     let parent = browser.browsingContext.currentWindowGlobal;
     Assert.throws(() => parent.getActor("Test"),
           /NS_ERROR_NOT_AVAILABLE/, "Should throw if its remoteTypes don't match.");
 
     await ContentTask.spawn(browser, {}, async function() {
--- a/js/xpconnect/loader/ScriptPreloader.cpp
+++ b/js/xpconnect/loader/ScriptPreloader.cpp
@@ -183,18 +183,18 @@ void ScriptPreloader::InitContentChild(C
                                                  wantScriptData);
   }
 }
 
 ProcessType ScriptPreloader::GetChildProcessType(const nsAString& remoteType) {
   if (remoteType.EqualsLiteral(EXTENSION_REMOTE_TYPE)) {
     return ProcessType::Extension;
   }
-  if (remoteType.EqualsLiteral(PRIVILEGED_REMOTE_TYPE)) {
-    return ProcessType::Privileged;
+  if (remoteType.EqualsLiteral(PRIVILEGEDABOUT_REMOTE_TYPE)) {
+    return ProcessType::PrivilegedAbout;
   }
   return ProcessType::Web;
 }
 
 namespace {
 
 static void TraceOp(JSTracer* trc, void* data) {
   auto preloader = static_cast<ScriptPreloader*>(data);
@@ -341,19 +341,19 @@ nsresult ScriptPreloader::Observe(nsISup
   return NS_OK;
 }
 
 void ScriptPreloader::FinishContentStartup() {
   MOZ_ASSERT(XRE_IsContentProcess());
 
 #ifdef DEBUG
   if (mContentStartupFinishedTopic.Equals(CONTENT_DOCUMENT_LOADED_TOPIC)) {
-    MOZ_ASSERT(sProcessType == ProcessType::Privileged);
+    MOZ_ASSERT(sProcessType == ProcessType::PrivilegedAbout);
   } else {
-    MOZ_ASSERT(sProcessType != ProcessType::Privileged);
+    MOZ_ASSERT(sProcessType != ProcessType::PrivilegedAbout);
   }
 #endif /* DEBUG */
 
   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
   obs->RemoveObserver(this, mContentStartupFinishedTopic.get());
 
   mSaveTimer = nullptr;
 
@@ -452,17 +452,17 @@ Result<Ok, nsresult> ScriptPreloader::In
   mCacheInitialized = true;
   mChildActor = cacheChild;
   sProcessType =
       GetChildProcessType(dom::ContentChild::GetSingleton()->GetRemoteType());
 
   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
   MOZ_RELEASE_ASSERT(obs);
 
-  if (sProcessType == ProcessType::Privileged) {
+  if (sProcessType == ProcessType::PrivilegedAbout) {
     // Since we control all of the documents loaded in the privileged
     // content process, we can increase the window of active time for the
     // ScriptPreloader to include the scripts that are loaded until the
     // first document finishes loading.
     mContentStartupFinishedTopic.AssignLiteral(CONTENT_DOCUMENT_LOADED_TOPIC);
   } else {
     // In the child process, we need to freeze the script cache before any
     // untrusted code has been executed. The insertion of the first DOM
--- a/js/xpconnect/loader/ScriptPreloader.h
+++ b/js/xpconnect/loader/ScriptPreloader.h
@@ -41,17 +41,17 @@ namespace loader {
 class InputBuffer;
 class ScriptCacheChild;
 
 enum class ProcessType : uint8_t {
   Uninitialized,
   Parent,
   Web,
   Extension,
-  Privileged,
+  PrivilegedAbout,
 };
 
 template <typename T>
 struct Matcher {
   virtual bool Matches(T) = 0;
 };
 }  // namespace loader
 
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -3343,23 +3343,23 @@ pref("dom.ipc.processCount", 4);
 #endif
 
 // Default to allow only one file:// URL content process.
 pref("dom.ipc.processCount.file", 1);
 
 // WebExtensions only support a single extension process.
 pref("dom.ipc.processCount.extension", 1);
 
-// Privileged content only supports a single content process.
-pref("dom.ipc.processCount.privileged", 1);
-
-// Keep a single privileged content process alive for performance reasons.
+// The privileged about process only supports a single content process.
+pref("dom.ipc.processCount.privilegedabout", 1);
+
+// Keep a single privileged about process alive for performance reasons.
 // e.g. we do not want to throw content processes out every time we navigate
 // away from about:newtab.
-pref("dom.ipc.keepProcessesAlive.privileged", 1);
+pref("dom.ipc.keepProcessesAlive.privilegedabout", 1);
 
 // Whether a native event loop should be used in the content process.
 #if defined(XP_WIN) || defined(XP_MACOSX)
 pref("dom.ipc.useNativeEventProcessing.content", false);
 #else
 pref("dom.ipc.useNativeEventProcessing.content", true);
 #endif
 
@@ -3381,17 +3381,19 @@ pref("browser.tabs.remote.separateFileUr
 
 // Pref that enables top level web content pages that are opened from file://
 // URI pages to run in the file content process.
 // This has been added in case breaking any window references between these
 // sorts of pages, which we have to do when we run them in the normal web
 // content process, causes compatibility issues.
 pref("browser.tabs.remote.allowLinkedWebInFileUriProcess", true);
 
-// Pref to control whether we use separate privileged content processes.
+// Pref to control whether we use a separate privileged content process
+// for about: pages. This pref name did not age well: we will have multiple
+// types of privileged content processes, each with different privileges.
 pref("browser.tabs.remote.separatePrivilegedContentProcess", false);
 
 // When this pref is enabled top level loads with a mismatched
 // Cross-Origin-Opener-Policy header will be loaded in a separate process.
 pref("browser.tabs.remote.useCrossOriginOpenerPolicy", false);
 
 // Enable the use of display-lists for SVG hit-testing and painting.
 pref("svg.display-lists.hit-testing.enabled", true);
--- a/netwerk/protocol/about/nsIAboutModule.idl
+++ b/netwerk/protocol/about/nsIAboutModule.idl
@@ -71,20 +71,20 @@ interface nsIAboutModule : nsISupports
      *
      * When adding a new about module with this flag make sure to also update
      * IsSafeToLinkForUntrustedContent() in nsAboutProtocolHandler.cpp
      */
     const unsigned long MAKE_LINKABLE = (1 << 7);
 
     /**
      * A flag that indicates that this URI can be loaded in the privileged
-     * content process if privileged content process is enabled. Ignored unless
+     * activity stream content process if said process is enabled. Ignored unless
      * URI_MUST_LOAD_IN_CHILD is also specified.
      */
-    const unsigned long URI_CAN_LOAD_IN_PRIVILEGED_CHILD = (1 << 8);
+    const unsigned long URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS = (1 << 8);
 
     /**
      * A flag that indicates that this URI must be loaded in an extension process (if available).
      */
     const unsigned long URI_MUST_LOAD_IN_EXTENSION_PROCESS = (1 << 9);
 
     /**
      * A method to get the flags that apply to a given about: URI.  The URI
--- a/toolkit/locales/en-US/toolkit/global/processTypes.ftl
+++ b/toolkit/locales/en-US/toolkit/global/processTypes.ftl
@@ -1,17 +1,17 @@
 # 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/.
 
 process-type-web = Web Content
 
 # process used to run privileged pages,
 # such as about:home
-process-type-privileged = Privileged Content
+process-type-privilegedabout = Privileged About
 
 process-type-extension = Extension
 
 # process used to open file:// URLs
 process-type-file = Local File
 
 # process used to isolate webpages that requested special
 # permission to allocate large amounts of memory
--- a/toolkit/modules/E10SUtils.jsm
+++ b/toolkit/modules/E10SUtils.jsm
@@ -8,17 +8,17 @@ var EXPORTED_SYMBOLS = ["E10SUtils"];
 
 const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
 const {XPCOMUtils} = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
 
 XPCOMUtils.defineLazyPreferenceGetter(this, "useSeparateFileUriProcess",
                                       "browser.tabs.remote.separateFileUriProcess", false);
 XPCOMUtils.defineLazyPreferenceGetter(this, "allowLinkedWebInFileUriProcess",
                                       "browser.tabs.remote.allowLinkedWebInFileUriProcess", false);
-XPCOMUtils.defineLazyPreferenceGetter(this, "useSeparatePrivilegedContentProcess",
+XPCOMUtils.defineLazyPreferenceGetter(this, "useSeparatePrivilegedAboutContentProcess",
                                       "browser.tabs.remote.separatePrivilegedContentProcess", false);
 XPCOMUtils.defineLazyPreferenceGetter(this, "useHttpResponseProcessSelection",
                                       "browser.tabs.remote.useHTTPResponseProcessSelection", false);
 XPCOMUtils.defineLazyPreferenceGetter(this, "useCrossOriginOpenerPolicy",
                                       "browser.tabs.remote.useCrossOriginOpenerPolicy", false);
 XPCOMUtils.defineLazyServiceGetter(this, "serializationHelper",
                                    "@mozilla.org/network/serialization-helper;1",
                                    "nsISerializationHelper");
@@ -41,17 +41,17 @@ function getAboutModule(aURL) {
 }
 
 const NOT_REMOTE = null;
 
 // These must match any similar ones in ContentParent.h and ProcInfo.h
 const WEB_REMOTE_TYPE = "web";
 const FILE_REMOTE_TYPE = "file";
 const EXTENSION_REMOTE_TYPE = "extension";
-const PRIVILEGED_REMOTE_TYPE = "privileged";
+const PRIVILEGEDABOUT_REMOTE_TYPE = "privilegedabout";
 
 // This must start with the WEB_REMOTE_TYPE above.
 const LARGE_ALLOCATION_REMOTE_TYPE = "webLargeAllocation";
 const DEFAULT_REMOTE_TYPE = WEB_REMOTE_TYPE;
 
 function validatedWebRemoteType(aPreferredRemoteType, aTargetUri, aCurrentUri, aRemoteSubframes) {
   // If the domain is whitelisted to allow it to use file:// URIs, then we have
   // to run it in a file content process, in case it uses file:// sub-resources.
@@ -98,17 +98,17 @@ function validatedWebRemoteType(aPreferr
 }
 
 var E10SUtils = {
   DEFAULT_REMOTE_TYPE,
   NOT_REMOTE,
   WEB_REMOTE_TYPE,
   FILE_REMOTE_TYPE,
   EXTENSION_REMOTE_TYPE,
-  PRIVILEGED_REMOTE_TYPE,
+  PRIVILEGEDABOUT_REMOTE_TYPE,
   LARGE_ALLOCATION_REMOTE_TYPE,
 
   useHttpResponseProcessSelection() {
     return useHttpResponseProcessSelection;
   },
   useCrossOriginOpenerPolicy() {
     return useCrossOriginOpenerPolicy;
   },
@@ -230,19 +230,19 @@ var E10SUtils = {
         }
 
         let flags = module.getURIFlags(aURI);
         if (flags & Ci.nsIAboutModule.URI_MUST_LOAD_IN_EXTENSION_PROCESS) {
           return WebExtensionPolicy.useRemoteWebExtensions ? EXTENSION_REMOTE_TYPE : NOT_REMOTE;
         }
 
         if (flags & Ci.nsIAboutModule.URI_MUST_LOAD_IN_CHILD) {
-          if ((flags & Ci.nsIAboutModule.URI_CAN_LOAD_IN_PRIVILEGED_CHILD) &&
-              useSeparatePrivilegedContentProcess) {
-            return PRIVILEGED_REMOTE_TYPE;
+          if ((flags & Ci.nsIAboutModule.URI_CAN_LOAD_IN_PRIVILEGEDABOUT_PROCESS) &&
+              useSeparatePrivilegedAboutContentProcess) {
+            return PRIVILEGEDABOUT_REMOTE_TYPE;
           }
           return DEFAULT_REMOTE_TYPE;
         }
 
         // If the about page can load in parent or child, it should be safe to
         // load in any remote type.
         if (flags & Ci.nsIAboutModule.URI_CAN_LOAD_IN_CHILD) {
           return aPreferredRemoteType;
--- a/widget/ProcInfo.h
+++ b/widget/ProcInfo.h
@@ -13,17 +13,17 @@
 namespace mozilla {
 
 // Process types
 enum class ProcType {
   // These must match the ones in ContentParent.h and E10SUtils.jsm
   Web,
   File,
   Extension,
-  Privileged,
+  PrivilegedAbout,
   WebLargeAllocation,
   // GPU process (only on Windows)
   Gpu,
   // RDD process (Windows and macOS)
   Rdd,
   // Socket process
   Socket,
   // Main process