Adding upstream version 124.0.1.upstream/124.0.1

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

86 files changed, 33407 insertions, 0 deletions

diff --git a/browser/modules/AboutNewTab.sys.mjs b/browser/modules/AboutNewTab.sys.mjs
new file mode 100644
index 0000000000..bff8bd3ce4
--- /dev/null
+++ b/browser/modules/AboutNewTab.sys.mjs
@@ -0,0 +1,247 @@
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ActivityStream: "resource://activity-stream/lib/ActivityStream.sys.mjs",
+  ObjectUtils: "resource://gre/modules/ObjectUtils.sys.mjs",
+});
+
+const ABOUT_URL = "about:newtab";
+const PREF_ACTIVITY_STREAM_DEBUG = "browser.newtabpage.activity-stream.debug";
+const TOPIC_APP_QUIT = "quit-application-granted";
+const BROWSER_READY_NOTIFICATION = "sessionstore-windows-restored";
+
+export const AboutNewTab = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIObserver",
+    "nsISupportsWeakReference",
+  ]),
+
+  // AboutNewTab
+  initialized: false,
+
+  willNotifyUser: false,
+
+  _activityStreamEnabled: false,
+  activityStream: null,
+  activityStreamDebug: false,
+
+  _cachedTopSites: null,
+
+  _newTabURL: ABOUT_URL,
+  _newTabURLOverridden: false,
+
+  /**
+   * init - Initializes an instance of Activity Stream if one doesn't exist already.
+   */
+  init() {
+    Services.obs.addObserver(this, TOPIC_APP_QUIT);
+    if (!AppConstants.RELEASE_OR_BETA) {
+      XPCOMUtils.defineLazyPreferenceGetter(
+        this,
+        "activityStreamDebug",
+        PREF_ACTIVITY_STREAM_DEBUG,
+        false,
+        () => {
+          this.notifyChange();
+        }
+      );
+    }
+
+    XPCOMUtils.defineLazyPreferenceGetter(
+      this,
+      "privilegedAboutProcessEnabled",
+      "browser.tabs.remote.separatePrivilegedContentProcess",
+      false,
+      () => {
+        this.notifyChange();
+      }
+    );
+
+    // More initialization happens here
+    this.toggleActivityStream(true);
+    this.initialized = true;
+
+    Services.obs.addObserver(this, BROWSER_READY_NOTIFICATION);
+  },
+
+  /**
+   * React to changes to the activity stream being enabled or not.
+   *
+   * This will only act if there is a change of state and if not overridden.
+   *
+   * @returns {Boolean} Returns if there has been a state change
+   *
+   * @param {Boolean}   stateEnabled    activity stream enabled state to set to
+   * @param {Boolean}   forceState      force state change
+   */
+  toggleActivityStream(stateEnabled, forceState = false) {
+    if (
+      !forceState &&
+      (this._newTabURLOverridden ||
+        stateEnabled === this._activityStreamEnabled)
+    ) {
+      // exit there is no change of state
+      return false;
+    }
+    if (stateEnabled) {
+      this._activityStreamEnabled = true;
+    } else {
+      this._activityStreamEnabled = false;
+    }
+
+    this._newTabURL = ABOUT_URL;
+    return true;
+  },
+
+  get newTabURL() {
+    return this._newTabURL;
+  },
+
+  set newTabURL(aNewTabURL) {
+    let newTabURL = aNewTabURL.trim();
+    if (newTabURL === ABOUT_URL) {
+      // avoid infinite redirects in case one sets the URL to about:newtab
+      this.resetNewTabURL();
+      return;
+    } else if (newTabURL === "") {
+      newTabURL = "about:blank";
+    }
+
+    this.toggleActivityStream(false);
+    this._newTabURL = newTabURL;
+    this._newTabURLOverridden = true;
+    this.notifyChange();
+  },
+
+  get newTabURLOverridden() {
+    return this._newTabURLOverridden;
+  },
+
+  get activityStreamEnabled() {
+    return this._activityStreamEnabled;
+  },
+
+  resetNewTabURL() {
+    this._newTabURLOverridden = false;
+    this._newTabURL = ABOUT_URL;
+    this.toggleActivityStream(true, true);
+    this.notifyChange();
+  },
+
+  notifyChange() {
+    Services.obs.notifyObservers(null, "newtab-url-changed", this._newTabURL);
+  },
+
+  /**
+   * onBrowserReady - Continues the initialization of Activity Stream after browser is ready.
+   */
+  onBrowserReady() {
+    if (this.activityStream && this.activityStream.initialized) {
+      return;
+    }
+
+    this.activityStream = new lazy.ActivityStream();
+    try {
+      this.activityStream.init();
+      this._subscribeToActivityStream();
+    } catch (e) {
+      console.error(e);
+    }
+  },
+
+  _subscribeToActivityStream() {
+    let unsubscribe = this.activityStream.store.subscribe(() => {
+      // If the top sites changed, broadcast "newtab-top-sites-changed". We
+      // ignore changes to the `screenshot` property in each site because
+      // screenshots are generated at times that are hard to predict and it ends
+      // up interfering with tests that rely on "newtab-top-sites-changed".
+      // Observers likely don't care about screenshots anyway.
+      let topSites = this.activityStream.store
+        .getState()
+        .TopSites.rows.map(site => {
+          site = { ...site };
+          delete site.screenshot;
+          return site;
+        });
+      if (!lazy.ObjectUtils.deepEqual(topSites, this._cachedTopSites)) {
+        this._cachedTopSites = topSites;
+        Services.obs.notifyObservers(null, "newtab-top-sites-changed");
+      }
+    });
+    this._unsubscribeFromActivityStream = () => {
+      try {
+        unsubscribe();
+      } catch (e) {
+        console.error(e);
+      }
+    };
+  },
+
+  /**
+   * uninit - Uninitializes Activity Stream if it exists.
+   */
+  uninit() {
+    if (this.activityStream) {
+      this._unsubscribeFromActivityStream?.();
+      this.activityStream.uninit();
+      this.activityStream = null;
+    }
+
+    this.initialized = false;
+  },
+
+  getTopSites() {
+    return this.activityStream
+      ? this.activityStream.store.getState().TopSites.rows
+      : [];
+  },
+
+  _alreadyRecordedTopsitesPainted: false,
+  _nonDefaultStartup: false,
+
+  noteNonDefaultStartup() {
+    this._nonDefaultStartup = true;
+  },
+
+  maybeRecordTopsitesPainted(timestamp) {
+    if (this._alreadyRecordedTopsitesPainted || this._nonDefaultStartup) {
+      return;
+    }
+
+    const SCALAR_KEY = "timestamps.about_home_topsites_first_paint";
+
+    let startupInfo = Services.startup.getStartupInfo();
+    let processStartTs = startupInfo.process.getTime();
+    let delta = Math.round(timestamp - processStartTs);
+    Services.telemetry.scalarSet(SCALAR_KEY, delta);
+    ChromeUtils.addProfilerMarker("aboutHomeTopsitesFirstPaint");
+    this._alreadyRecordedTopsitesPainted = true;
+  },
+
+  // nsIObserver implementation
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case TOPIC_APP_QUIT: {
+        // We defer to this to the next tick of the event loop since the
+        // AboutHomeStartupCache might want to read from the ActivityStream
+        // store during TOPIC_APP_QUIT.
+        Services.tm.dispatchToMainThread(() => this.uninit());
+        break;
+      }
+      case BROWSER_READY_NOTIFICATION: {
+        Services.obs.removeObserver(this, BROWSER_READY_NOTIFICATION);
+        // Avoid running synchronously during this event that's used for timing
+        Services.tm.dispatchToMainThread(() => this.onBrowserReady());
+        break;
+      }
+    }
+  },
+};
diff --git a/browser/modules/AsyncTabSwitcher.sys.mjs b/browser/modules/AsyncTabSwitcher.sys.mjs
new file mode 100644
index 0000000000..4ecdcf7882
--- /dev/null
+++ b/browser/modules/AsyncTabSwitcher.sys.mjs
@@ -0,0 +1,1508 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PictureInPicture: "resource://gre/modules/PictureInPicture.sys.mjs",
+});
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTabWarmingEnabled",
+  "browser.tabs.remote.warmup.enabled"
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTabWarmingMax",
+  "browser.tabs.remote.warmup.maxTabs"
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTabWarmingUnloadDelayMs",
+  "browser.tabs.remote.warmup.unloadDelayMs"
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTabCacheSize",
+  "browser.tabs.remote.tabCacheSize"
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTabUnloadDelay",
+  "browser.tabs.remote.unloadDelayMs",
+  300
+);
+
+/**
+ * The tab switcher is responsible for asynchronously switching
+ * tabs in e10s. It waits until the new tab is ready (i.e., the
+ * layer tree is available) before switching to it. Then it
+ * unloads the layer tree for the old tab.
+ *
+ * The tab switcher is a state machine. For each tab, it
+ * maintains state about whether the layer tree for the tab is
+ * available, being loaded, being unloaded, or unavailable. It
+ * also keeps track of the tab currently being displayed, the tab
+ * it's trying to load, and the tab the user has asked to switch
+ * to. The switcher object is created upon tab switch. It is
+ * released when there are no pending tabs to load or unload.
+ *
+ * The following general principles have guided the design:
+ *
+ * 1. We only request one layer tree at a time. If the user
+ * switches to a different tab while waiting, we don't request
+ * the new layer tree until the old tab has loaded or timed out.
+ *
+ * 2. If loading the layers for a tab times out, we show the
+ * spinner and possibly request the layer tree for another tab if
+ * the user has requested one.
+ *
+ * 3. We discard layer trees on a delay. This way, if the user is
+ * switching among the same tabs frequently, we don't continually
+ * load the same tabs.
+ *
+ * It's important that we always show either the spinner or a tab
+ * whose layers are available. Otherwise the compositor will draw
+ * an entirely black frame, which is very jarring. To ensure this
+ * never happens when switching away from a tab, we assume the
+ * old tab might still be drawn until a MozAfterPaint event
+ * occurs. Because layout and compositing happen asynchronously,
+ * we don't have any other way of knowing when the switch
+ * actually takes place. Therefore, we don't unload the old tab
+ * until the next MozAfterPaint event.
+ */
+export class AsyncTabSwitcher {
+  constructor(tabbrowser) {
+    this.log("START");
+
+    // How long to wait for a tab's layers to load. After this
+    // time elapses, we're free to put up the spinner and start
+    // trying to load a different tab.
+    this.TAB_SWITCH_TIMEOUT = 400; // ms
+
+    // When the user hasn't switched tabs for this long, we unload
+    // layers for all tabs that aren't in use.
+    this.UNLOAD_DELAY = lazy.gTabUnloadDelay; // ms
+
+    // The next three tabs form the principal state variables.
+    // See the assertions in postActions for their invariants.
+
+    // Tab the user requested most recently.
+    this.requestedTab = tabbrowser.selectedTab;
+
+    // Tab we're currently trying to load.
+    this.loadingTab = null;
+
+    // We show this tab in case the requestedTab hasn't loaded yet.
+    this.lastVisibleTab = tabbrowser.selectedTab;
+
+    // Auxilliary state variables:
+
+    this.visibleTab = tabbrowser.selectedTab; // Tab that's on screen.
+    this.spinnerTab = null; // Tab showing a spinner.
+    this.blankTab = null; // Tab showing blank.
+    this.lastPrimaryTab = tabbrowser.selectedTab; // Tab with primary="true"
+
+    this.tabbrowser = tabbrowser;
+    this.window = tabbrowser.ownerGlobal;
+    this.loadTimer = null; // TAB_SWITCH_TIMEOUT nsITimer instance.
+    this.unloadTimer = null; // UNLOAD_DELAY nsITimer instance.
+
+    // Map from tabs to STATE_* (below).
+    this.tabState = new Map();
+
+    // True if we're in the midst of switching tabs.
+    this.switchInProgress = false;
+
+    // Transaction id for the composite that will show the requested
+    // tab for the first tab after a tab switch.
+    // Set to -1 when we're not waiting for notification of a
+    // completed switch.
+    this.switchPaintId = -1;
+
+    // Set of tabs that might be visible right now. We maintain
+    // this set because we can't be sure when a tab is actually
+    // drawn. A tab is added to this set when we ask to make it
+    // visible. All tabs but the most recently shown tab are
+    // removed from the set upon MozAfterPaint.
+    this.maybeVisibleTabs = new Set([tabbrowser.selectedTab]);
+
+    // This holds onto the set of tabs that we've been asked to warm up,
+    // and tabs are evicted once they're done loading or are unloaded.
+    this.warmingTabs = new WeakSet();
+
+    this.STATE_UNLOADED = 0;
+    this.STATE_LOADING = 1;
+    this.STATE_LOADED = 2;
+    this.STATE_UNLOADING = 3;
+
+    // re-entrancy guard:
+    this._processing = false;
+
+    // For telemetry, keeps track of what most recently cleared
+    // the loadTimer, which can tell us something about the cause
+    // of tab switch spinners.
+    this._loadTimerClearedBy = "none";
+
+    this._useDumpForLogging = false;
+    this._logInit = false;
+    this._logFlags = [];
+
+    this.window.addEventListener("MozAfterPaint", this);
+    this.window.addEventListener("MozLayerTreeReady", this);
+    this.window.addEventListener("MozLayerTreeCleared", this);
+    this.window.addEventListener("TabRemotenessChange", this);
+    this.window.addEventListener("SwapDocShells", this, true);
+    this.window.addEventListener("EndSwapDocShells", this, true);
+    this.window.document.addEventListener("visibilitychange", this);
+
+    let initialTab = this.requestedTab;
+    let initialBrowser = initialTab.linkedBrowser;
+
+    let tabIsLoaded =
+      !initialBrowser.isRemoteBrowser ||
+      initialBrowser.frameLoader.remoteTab?.hasLayers;
+
+    // If we minimized the window before the switcher was activated,
+    // we might have set  the preserveLayers flag for the current
+    // browser. Let's clear it.
+    initialBrowser.preserveLayers(false);
+
+    if (!this.windowHidden) {
+      this.log("Initial tab is loaded?: " + tabIsLoaded);
+      this.setTabState(
+        initialTab,
+        tabIsLoaded ? this.STATE_LOADED : this.STATE_LOADING
+      );
+    }
+
+    for (let ppBrowser of this.tabbrowser._printPreviewBrowsers) {
+      let ppTab = this.tabbrowser.getTabForBrowser(ppBrowser);
+      let state = ppBrowser.hasLayers ? this.STATE_LOADED : this.STATE_LOADING;
+      this.setTabState(ppTab, state);
+    }
+  }
+
+  destroy() {
+    if (this.unloadTimer) {
+      this.clearTimer(this.unloadTimer);
+      this.unloadTimer = null;
+    }
+    if (this.loadTimer) {
+      this.clearTimer(this.loadTimer);
+      this.loadTimer = null;
+    }
+
+    this.window.removeEventListener("MozAfterPaint", this);
+    this.window.removeEventListener("MozLayerTreeReady", this);
+    this.window.removeEventListener("MozLayerTreeCleared", this);
+    this.window.removeEventListener("TabRemotenessChange", this);
+    this.window.removeEventListener("SwapDocShells", this, true);
+    this.window.removeEventListener("EndSwapDocShells", this, true);
+    this.window.document.removeEventListener("visibilitychange", this);
+
+    this.tabbrowser._switcher = null;
+  }
+
+  // Wraps nsITimer. Must not use the vanilla setTimeout and
+  // clearTimeout, because they will be blocked by nsIPromptService
+  // dialogs.
+  setTimer(callback, timeout) {
+    let event = {
+      notify: callback,
+    };
+
+    var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    timer.initWithCallback(event, timeout, Ci.nsITimer.TYPE_ONE_SHOT);
+    return timer;
+  }
+
+  clearTimer(timer) {
+    timer.cancel();
+  }
+
+  getTabState(tab) {
+    let state = this.tabState.get(tab);
+
+    // As an optimization, we lazily evaluate the state of tabs
+    // that we've never seen before. Once we've figured it out,
+    // we stash it in our state map.
+    if (state === undefined) {
+      state = this.STATE_UNLOADED;
+
+      if (tab && tab.linkedPanel) {
+        let b = tab.linkedBrowser;
+        if (b.renderLayers && b.hasLayers) {
+          state = this.STATE_LOADED;
+        } else if (b.renderLayers && !b.hasLayers) {
+          state = this.STATE_LOADING;
+        } else if (!b.renderLayers && b.hasLayers) {
+          state = this.STATE_UNLOADING;
+        }
+      }
+
+      this.setTabStateNoAction(tab, state);
+    }
+
+    return state;
+  }
+
+  setTabStateNoAction(tab, state) {
+    if (state == this.STATE_UNLOADED) {
+      this.tabState.delete(tab);
+    } else {
+      this.tabState.set(tab, state);
+    }
+  }
+
+  setTabState(tab, state) {
+    if (state == this.getTabState(tab)) {
+      return;
+    }
+
+    this.setTabStateNoAction(tab, state);
+
+    let browser = tab.linkedBrowser;
+    let { remoteTab } = browser.frameLoader;
+    if (state == this.STATE_LOADING) {
+      this.assert(!this.windowHidden);
+
+      // If we're not in the process of warming this tab, we
+      // don't need to delay activating its DocShell.
+      if (!this.warmingTabs.has(tab)) {
+        browser.docShellIsActive = true;
+      }
+
+      if (remoteTab) {
+        browser.renderLayers = true;
+        remoteTab.priorityHint = true;
+      }
+      if (browser.hasLayers) {
+        this.onLayersReady(browser);
+      }
+    } else if (state == this.STATE_UNLOADING) {
+      this.unwarmTab(tab);
+      // Setting the docShell to be inactive will also cause it
+      // to stop rendering layers.
+      browser.docShellIsActive = false;
+      if (remoteTab) {
+        remoteTab.priorityHint = false;
+      }
+      if (!browser.hasLayers) {
+        this.onLayersCleared(browser);
+      }
+    } else if (state == this.STATE_LOADED) {
+      this.maybeActivateDocShell(tab);
+    }
+
+    if (!tab.linkedBrowser.isRemoteBrowser) {
+      // setTabState is potentially re-entrant, so we must re-get the state for
+      // this assertion.
+      let nonRemoteState = this.getTabState(tab);
+      // Non-remote tabs can never stay in the STATE_LOADING
+      // or STATE_UNLOADING states. By the time this function
+      // exits, a non-remote tab must be in STATE_LOADED or
+      // STATE_UNLOADED, since the painting and the layer
+      // upload happen synchronously.
+      this.assert(
+        nonRemoteState == this.STATE_UNLOADED ||
+          nonRemoteState == this.STATE_LOADED
+      );
+    }
+  }
+
+  get windowHidden() {
+    return this.window.document.hidden;
+  }
+
+  get tabLayerCache() {
+    return this.tabbrowser._tabLayerCache;
+  }
+
+  finish() {
+    this.log("FINISH");
+
+    this.assert(this.tabbrowser._switcher);
+    this.assert(this.tabbrowser._switcher === this);
+    this.assert(!this.spinnerTab);
+    this.assert(!this.blankTab);
+    this.assert(!this.loadTimer);
+    this.assert(!this.loadingTab);
+    this.assert(this.lastVisibleTab === this.requestedTab);
+    this.assert(
+      this.windowHidden ||
+        this.getTabState(this.requestedTab) == this.STATE_LOADED
+    );
+
+    this.destroy();
+
+    this.window.document.commandDispatcher.unlock();
+
+    let event = new this.window.CustomEvent("TabSwitchDone", {
+      bubbles: true,
+      cancelable: true,
+    });
+    this.tabbrowser.dispatchEvent(event);
+  }
+
+  // This function is called after all the main state changes to
+  // make sure we display the right tab.
+  updateDisplay() {
+    let requestedTabState = this.getTabState(this.requestedTab);
+    let requestedBrowser = this.requestedTab.linkedBrowser;
+
+    // It is often more desirable to show a blank tab when appropriate than
+    // the tab switch spinner - especially since the spinner is usually
+    // preceded by a perceived lag of TAB_SWITCH_TIMEOUT ms in the
+    // tab switch. We can hide this lag, and hide the time being spent
+    // constructing BrowserChild's, layer trees, etc, by showing a blank
+    // tab instead and focusing it immediately.
+    let shouldBeBlank = false;
+    if (requestedBrowser.isRemoteBrowser) {
+      // If a tab is remote and the window is not minimized, we can show a
+      // blank tab instead of a spinner in the following cases:
+      //
+      // 1. The tab has just crashed, and we haven't started showing the
+      //    tab crashed page yet (in this case, the RemoteTab 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 isBusy = this.requestedTab.hasAttribute("busy");
+      let isLocalAbout = requestedBrowser.currentURI.schemeIs("about");
+      let hasSufficientlyLoaded = !isBusy && !isLocalAbout;
+
+      let fl = requestedBrowser.frameLoader;
+      shouldBeBlank =
+        !this.windowHidden &&
+        (!fl.remoteTab ||
+          (!hasSufficientlyLoaded && !fl.remoteTab.hasPresented));
+
+      if (this.logging()) {
+        let flag = shouldBeBlank ? "blank" : "nonblank";
+        this.addLogFlag(
+          flag,
+          this.windowHidden,
+          fl.remoteTab,
+          isBusy,
+          isLocalAbout,
+          fl.remoteTab ? fl.remoteTab.hasPresented : 0
+        );
+      }
+    }
+
+    if (requestedBrowser.isRemoteBrowser) {
+      this.addLogFlag("isRemote");
+    }
+
+    // Figure out which tab we actually want visible right now.
+    let showTab = null;
+    if (
+      requestedTabState != this.STATE_LOADED &&
+      this.lastVisibleTab &&
+      this.loadTimer &&
+      !shouldBeBlank
+    ) {
+      // If we can't show the requestedTab, and lastVisibleTab is
+      // available, show it.
+      showTab = this.lastVisibleTab;
+    } else {
+      // Show the requested tab. If it's not available, we'll show the spinner or a blank tab.
+      showTab = this.requestedTab;
+    }
+
+    // First, let's deal with blank tabs, which we show instead
+    // of the spinner when the tab is not currently set up
+    // properly in the content process.
+    if (!shouldBeBlank && this.blankTab) {
+      this.blankTab.linkedBrowser.removeAttribute("blank");
+      this.blankTab = null;
+    } else if (shouldBeBlank && this.blankTab !== showTab) {
+      if (this.blankTab) {
+        this.blankTab.linkedBrowser.removeAttribute("blank");
+      }
+      this.blankTab = showTab;
+      this.blankTab.linkedBrowser.setAttribute("blank", "true");
+    }
+
+    // Show or hide the spinner as needed.
+    let needSpinner =
+      this.getTabState(showTab) != this.STATE_LOADED &&
+      !this.windowHidden &&
+      !shouldBeBlank &&
+      !this.loadTimer;
+
+    if (!needSpinner && this.spinnerTab) {
+      this.noteSpinnerHidden();
+      this.tabbrowser.tabpanels.removeAttribute("pendingpaint");
+      this.spinnerTab.linkedBrowser.removeAttribute("pendingpaint");
+      this.spinnerTab = null;
+    } else if (needSpinner && this.spinnerTab !== showTab) {
+      if (this.spinnerTab) {
+        this.spinnerTab.linkedBrowser.removeAttribute("pendingpaint");
+      } else {
+        this.noteSpinnerDisplayed();
+      }
+      this.spinnerTab = showTab;
+      this.tabbrowser.tabpanels.toggleAttribute("pendingpaint", true);
+      this.spinnerTab.linkedBrowser.toggleAttribute("pendingpaint", true);
+    }
+
+    // Switch to the tab we've decided to make visible.
+    if (this.visibleTab !== showTab) {
+      this.tabbrowser._adjustFocusBeforeTabSwitch(this.visibleTab, showTab);
+      this.visibleTab = showTab;
+
+      this.maybeVisibleTabs.add(showTab);
+
+      let tabpanels = this.tabbrowser.tabpanels;
+      let showPanel = this.tabbrowser.tabContainer.getRelatedElement(showTab);
+      let index = Array.prototype.indexOf.call(tabpanels.children, showPanel);
+      if (index != -1) {
+        this.log(`Switch to tab ${index} - ${this.tinfo(showTab)}`);
+        tabpanels.updateSelectedIndex(index);
+        if (showTab === this.requestedTab) {
+          if (requestedTabState == this.STATE_LOADED) {
+            // The new tab will be made visible in the next paint, record the expected
+            // transaction id for that, and we'll mark when we get notified of its
+            // completion.
+            this.switchPaintId = this.window.windowUtils.lastTransactionId + 1;
+          } else {
+            this.noteMakingTabVisibleWithoutLayers();
+          }
+
+          this.tabbrowser._adjustFocusAfterTabSwitch(showTab);
+          this.window.gURLBar.afterTabSwitchFocusChange();
+          this.maybeActivateDocShell(this.requestedTab);
+        }
+      }
+
+      // This doesn't necessarily exist if we're a new window and haven't switched tabs yet
+      if (this.lastVisibleTab) {
+        this.lastVisibleTab._visuallySelected = false;
+      }
+
+      this.visibleTab._visuallySelected = true;
+    }
+
+    this.lastVisibleTab = this.visibleTab;
+  }
+
+  assert(cond) {
+    if (!cond) {
+      dump("Assertion failure\n" + Error().stack);
+
+      // Don't break a user's browser if an assertion fails.
+      if (AppConstants.DEBUG) {
+        throw new Error("Assertion failure");
+      }
+    }
+  }
+
+  maybeClearLoadTimer(caller) {
+    if (this.loadingTab) {
+      this._loadTimerClearedBy = caller;
+      this.loadingTab = null;
+      if (this.loadTimer) {
+        this.clearTimer(this.loadTimer);
+        this.loadTimer = null;
+      }
+    }
+  }
+
+  // We've decided to try to load requestedTab.
+  loadRequestedTab() {
+    this.assert(!this.loadTimer);
+    this.assert(!this.windowHidden);
+
+    // loadingTab can be non-null here if we timed out loading the current tab.
+    // In that case we just overwrite it with a different tab; it's had its chance.
+    this.loadingTab = this.requestedTab;
+    this.log("Loading tab " + this.tinfo(this.loadingTab));
+
+    this.loadTimer = this.setTimer(
+      () => this.handleEvent({ type: "loadTimeout" }),
+      this.TAB_SWITCH_TIMEOUT
+    );
+    this.setTabState(this.requestedTab, this.STATE_LOADING);
+  }
+
+  maybeActivateDocShell(tab) {
+    // If we've reached the point where the requested tab has entered
+    // the loaded state, but the DocShell is still not yet active, we
+    // should activate it.
+    let browser = tab.linkedBrowser;
+    let state = this.getTabState(tab);
+    let canCheckDocShellState =
+      !browser.mDestroyed &&
+      (browser.docShell || browser.frameLoader.remoteTab);
+    if (
+      tab == this.requestedTab &&
+      canCheckDocShellState &&
+      state == this.STATE_LOADED &&
+      !browser.docShellIsActive &&
+      !this.windowHidden
+    ) {
+      browser.docShellIsActive = true;
+      this.logState(
+        "Set requested tab docshell to active and preserveLayers to false"
+      );
+      // If we minimized the window before the switcher was activated,
+      // we might have set the preserveLayers flag for the current
+      // browser. Let's clear it.
+      browser.preserveLayers(false);
+    }
+  }
+
+  // This function runs before every event. It fixes up the state
+  // to account for closed tabs.
+  preActions() {
+    this.assert(this.tabbrowser._switcher);
+    this.assert(this.tabbrowser._switcher === this);
+
+    for (let i = 0; i < this.tabLayerCache.length; i++) {
+      let tab = this.tabLayerCache[i];
+      if (!tab.linkedBrowser) {
+        this.tabState.delete(tab);
+        this.tabLayerCache.splice(i, 1);
+        i--;
+      }
+    }
+
+    for (let [tab] of this.tabState) {
+      if (!tab.linkedBrowser) {
+        this.tabState.delete(tab);
+        this.unwarmTab(tab);
+      }
+    }
+
+    if (this.lastVisibleTab && !this.lastVisibleTab.linkedBrowser) {
+      this.lastVisibleTab = null;
+    }
+    if (this.lastPrimaryTab && !this.lastPrimaryTab.linkedBrowser) {
+      this.lastPrimaryTab = null;
+    }
+    if (this.blankTab && !this.blankTab.linkedBrowser) {
+      this.blankTab = null;
+    }
+    if (this.spinnerTab && !this.spinnerTab.linkedBrowser) {
+      this.noteSpinnerHidden();
+      this.spinnerTab = null;
+    }
+    if (this.loadingTab && !this.loadingTab.linkedBrowser) {
+      this.maybeClearLoadTimer("preActions");
+    }
+  }
+
+  // This code runs after we've responded to an event or requested a new
+  // tab. It's expected that we've already updated all the principal
+  // state variables. This function takes care of updating any auxilliary
+  // state.
+  postActions(eventString) {
+    // Once we finish loading loadingTab, we null it out. So the state should
+    // always be LOADING.
+    this.assert(
+      !this.loadingTab ||
+        this.getTabState(this.loadingTab) == this.STATE_LOADING
+    );
+
+    // We guarantee that loadingTab is non-null iff loadTimer is non-null. So
+    // the timer is set only when we're loading something.
+    this.assert(!this.loadTimer || this.loadingTab);
+    this.assert(!this.loadingTab || this.loadTimer);
+
+    // If we're switching to a non-remote tab, there's no need to wait
+    // for it to send layers to the compositor, as this will happen
+    // synchronously. Clearing this here means that in the next step,
+    // we can load the non-remote browser immediately.
+    if (!this.requestedTab.linkedBrowser.isRemoteBrowser) {
+      this.maybeClearLoadTimer("postActions");
+    }
+
+    // If we're not loading anything, try loading the requested tab.
+    let stateOfRequestedTab = this.getTabState(this.requestedTab);
+    if (
+      !this.loadTimer &&
+      !this.windowHidden &&
+      (stateOfRequestedTab == this.STATE_UNLOADED ||
+        stateOfRequestedTab == this.STATE_UNLOADING ||
+        this.warmingTabs.has(this.requestedTab))
+    ) {
+      this.assert(stateOfRequestedTab != this.STATE_LOADED);
+      this.loadRequestedTab();
+    }
+
+    let numBackgroundCached = 0;
+    for (let tab of this.tabLayerCache) {
+      if (tab !== this.requestedTab) {
+        numBackgroundCached++;
+      }
+    }
+
+    // See how many tabs still have work to do.
+    let numPending = 0;
+    let numWarming = 0;
+    for (let [tab, state] of this.tabState) {
+      if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
+        continue;
+      }
+
+      if (
+        state == this.STATE_LOADED &&
+        tab !== this.requestedTab &&
+        !this.tabLayerCache.includes(tab)
+      ) {
+        numPending++;
+
+        if (tab !== this.visibleTab) {
+          numWarming++;
+        }
+      }
+      if (state == this.STATE_LOADING || state == this.STATE_UNLOADING) {
+        numPending++;
+      }
+    }
+
+    this.updateDisplay();
+
+    // It's possible for updateDisplay to trigger one of our own event
+    // handlers, which might cause finish() to already have been called.
+    // Check for that before calling finish() again.
+    if (!this.tabbrowser._switcher) {
+      return;
+    }
+
+    this.maybeFinishTabSwitch();
+
+    if (numBackgroundCached > 0) {
+      this.deactivateCachedBackgroundTabs();
+    }
+
+    if (numWarming > lazy.gTabWarmingMax) {
+      this.logState("Hit tabWarmingMax");
+      if (this.unloadTimer) {
+        this.clearTimer(this.unloadTimer);
+      }
+      this.unloadNonRequiredTabs();
+    }
+
+    if (numPending == 0) {
+      this.finish();
+    }
+
+    this.logState("/" + eventString);
+  }
+
+  // Fires when we're ready to unload unused tabs.
+  onUnloadTimeout() {
+    this.unloadTimer = null;
+    this.unloadNonRequiredTabs();
+  }
+
+  deactivateCachedBackgroundTabs() {
+    for (let tab of this.tabLayerCache) {
+      if (tab !== this.requestedTab) {
+        let browser = tab.linkedBrowser;
+        browser.preserveLayers(true);
+        browser.docShellIsActive = false;
+      }
+    }
+  }
+
+  // If there are any non-visible and non-requested tabs in
+  // STATE_LOADED, sets them to STATE_UNLOADING. Also queues
+  // up the unloadTimer to run onUnloadTimeout if there are still
+  // tabs in the process of unloading.
+  unloadNonRequiredTabs() {
+    this.warmingTabs = new WeakSet();
+    let numPending = 0;
+
+    // Unload any tabs that can be unloaded.
+    for (let [tab, state] of this.tabState) {
+      if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
+        continue;
+      }
+
+      let isInLayerCache = this.tabLayerCache.includes(tab);
+
+      if (
+        state == this.STATE_LOADED &&
+        !this.maybeVisibleTabs.has(tab) &&
+        tab !== this.lastVisibleTab &&
+        tab !== this.loadingTab &&
+        tab !== this.requestedTab &&
+        !isInLayerCache
+      ) {
+        this.setTabState(tab, this.STATE_UNLOADING);
+      }
+
+      if (
+        state != this.STATE_UNLOADED &&
+        tab !== this.requestedTab &&
+        !isInLayerCache
+      ) {
+        numPending++;
+      }
+    }
+
+    if (numPending) {
+      // Keep the timer going since there may be more tabs to unload.
+      this.unloadTimer = this.setTimer(
+        () => this.handleEvent({ type: "unloadTimeout" }),
+        this.UNLOAD_DELAY
+      );
+    }
+  }
+
+  // Fires when an ongoing load has taken too long.
+  onLoadTimeout() {
+    this.maybeClearLoadTimer("onLoadTimeout");
+  }
+
+  // Fires when the layers become available for a tab.
+  onLayersReady(browser) {
+    let tab = this.tabbrowser.getTabForBrowser(browser);
+    if (!tab) {
+      // We probably got a layer update from a tab that got before
+      // the switcher was created, or for browser that's not being
+      // tracked by the async tab switcher (like the preloaded about:newtab).
+      return;
+    }
+
+    this.logState(`onLayersReady(${tab._tPos}, ${browser.isRemoteBrowser})`);
+    this.assert(
+      this.getTabState(tab) == this.STATE_LOADING ||
+        this.getTabState(tab) == this.STATE_LOADED
+    );
+    this.setTabState(tab, this.STATE_LOADED);
+    this.unwarmTab(tab);
+
+    if (this.loadingTab === tab) {
+      this.maybeClearLoadTimer("onLayersReady");
+    }
+  }
+
+  // Fires when we paint the screen. Any tab switches we initiated
+  // previously are done, so there's no need to keep the old layers
+  // around.
+  onPaint(event) {
+    this.addLogFlag(
+      "onPaint",
+      this.switchPaintId != -1,
+      event.transactionId >= this.switchPaintId
+    );
+    this.notePaint(event);
+    this.maybeVisibleTabs.clear();
+  }
+
+  // Called when we're done clearing the layers for a tab.
+  onLayersCleared(browser) {
+    let tab = this.tabbrowser.getTabForBrowser(browser);
+    if (!tab) {
+      return;
+    }
+    this.logState(`onLayersCleared(${tab._tPos})`);
+    this.assert(
+      this.getTabState(tab) == this.STATE_UNLOADING ||
+        this.getTabState(tab) == this.STATE_UNLOADED
+    );
+    this.setTabState(tab, this.STATE_UNLOADED);
+  }
+
+  // Called when a tab switches from remote to non-remote. In this case
+  // a MozLayerTreeReady notification that we requested may never fire,
+  // so we need to simulate it.
+  onRemotenessChange(tab) {
+    this.logState(
+      `onRemotenessChange(${tab._tPos}, ${tab.linkedBrowser.isRemoteBrowser})`
+    );
+    if (!tab.linkedBrowser.isRemoteBrowser) {
+      if (this.getTabState(tab) == this.STATE_LOADING) {
+        this.onLayersReady(tab.linkedBrowser);
+      } else if (this.getTabState(tab) == this.STATE_UNLOADING) {
+        this.onLayersCleared(tab.linkedBrowser);
+      }
+    } else if (this.getTabState(tab) == this.STATE_LOADED) {
+      // A tab just changed from non-remote to remote, which means
+      // that it's gone back into the STATE_LOADING state until
+      // it sends up a layer tree.
+      this.setTabState(tab, this.STATE_LOADING);
+    }
+  }
+
+  onTabRemoved(tab) {
+    if (this.lastVisibleTab == tab) {
+      this.handleEvent({ type: "tabRemoved", tab });
+    }
+  }
+
+  // Called when a tab has been removed, and the browser node is
+  // about to be removed from the DOM.
+  onTabRemovedImpl(tab) {
+    this.lastVisibleTab = null;
+  }
+
+  onVisibilityChange() {
+    if (this.windowHidden) {
+      for (let [tab, state] of this.tabState) {
+        if (!this.shouldDeactivateDocShell(tab.linkedBrowser)) {
+          continue;
+        }
+
+        if (state == this.STATE_LOADING || state == this.STATE_LOADED) {
+          this.setTabState(tab, this.STATE_UNLOADING);
+        }
+      }
+      this.maybeClearLoadTimer("onSizeModeOrOcc");
+    } else {
+      // We're no longer minimized or occluded. This means we might want
+      // to activate the current tab's docShell.
+      this.maybeActivateDocShell(this.tabbrowser.selectedTab);
+    }
+  }
+
+  onSwapDocShells(ourBrowser, otherBrowser) {
+    // This event fires before the swap. ourBrowser is from
+    // our window. We save the state of otherBrowser since ourBrowser
+    // needs to take on that state at the end of the swap.
+
+    let otherTabbrowser = otherBrowser.ownerGlobal.gBrowser;
+    let otherState;
+    if (otherTabbrowser && otherTabbrowser._switcher) {
+      let otherTab = otherTabbrowser.getTabForBrowser(otherBrowser);
+      let otherSwitcher = otherTabbrowser._switcher;
+      otherState = otherSwitcher.getTabState(otherTab);
+    } else {
+      otherState = otherBrowser.docShellIsActive
+        ? this.STATE_LOADED
+        : this.STATE_UNLOADED;
+    }
+    if (!this.swapMap) {
+      this.swapMap = new WeakMap();
+    }
+    this.swapMap.set(otherBrowser, {
+      state: otherState,
+    });
+  }
+
+  onEndSwapDocShells(ourBrowser, otherBrowser) {
+    // The swap has happened. We reset the loadingTab in
+    // case it has been swapped. We also set ourBrowser's state
+    // to whatever otherBrowser's state was before the swap.
+
+    // Clearing the load timer means that we will
+    // immediately display a spinner if ourBrowser isn't
+    // ready yet. Typically it will already be ready
+    // though. If it's not, we're probably in a new window,
+    // in which case we have no other tabs to display anyway.
+    this.maybeClearLoadTimer("onEndSwapDocShells");
+
+    let { state: otherState } = this.swapMap.get(otherBrowser);
+
+    this.swapMap.delete(otherBrowser);
+
+    let ourTab = this.tabbrowser.getTabForBrowser(ourBrowser);
+    if (ourTab) {
+      this.setTabStateNoAction(ourTab, otherState);
+    }
+  }
+
+  /**
+   * Check if the browser should be deactivated. If the browser is a print preivew or
+   * PiP browser then we won't deactive it.
+   * @param browser The browser to check if it should be deactivated
+   * @returns false if a print preview or PiP browser else true
+   */
+  shouldDeactivateDocShell(browser) {
+    return !(
+      this.tabbrowser._printPreviewBrowsers.has(browser) ||
+      lazy.PictureInPicture.isOriginatingBrowser(browser)
+    );
+  }
+
+  shouldActivateDocShell(browser) {
+    let tab = this.tabbrowser.getTabForBrowser(browser);
+    let state = this.getTabState(tab);
+    return state == this.STATE_LOADING || state == this.STATE_LOADED;
+  }
+
+  activateBrowserForPrintPreview(browser) {
+    let tab = this.tabbrowser.getTabForBrowser(browser);
+    let state = this.getTabState(tab);
+    if (state != this.STATE_LOADING && state != this.STATE_LOADED) {
+      this.setTabState(tab, this.STATE_LOADING);
+      this.logState(
+        "Activated browser " + this.tinfo(tab) + " for print preview"
+      );
+    }
+  }
+
+  canWarmTab(tab) {
+    if (!lazy.gTabWarmingEnabled) {
+      return false;
+    }
+
+    if (!tab) {
+      return false;
+    }
+
+    // If the tab is not yet inserted, closing, not remote,
+    // crashed, already visible, or already requested, warming
+    // up the tab makes no sense.
+    if (
+      this.windowHidden ||
+      !tab.linkedPanel ||
+      tab.closing ||
+      !tab.linkedBrowser.isRemoteBrowser ||
+      !tab.linkedBrowser.frameLoader.remoteTab
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  shouldWarmTab(tab) {
+    if (this.canWarmTab(tab)) {
+      // Tabs that are already in STATE_LOADING or STATE_LOADED
+      // have no need to be warmed up.
+      let state = this.getTabState(tab);
+      if (state === this.STATE_UNLOADING || state === this.STATE_UNLOADED) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  unwarmTab(tab) {
+    this.warmingTabs.delete(tab);
+  }
+
+  warmupTab(tab) {
+    if (!this.shouldWarmTab(tab)) {
+      return;
+    }
+
+    this.logState("warmupTab " + this.tinfo(tab));
+
+    this.warmingTabs.add(tab);
+    this.setTabState(tab, this.STATE_LOADING);
+    this.queueUnload(lazy.gTabWarmingUnloadDelayMs);
+  }
+
+  cleanUpTabAfterEviction(tab) {
+    this.assert(tab !== this.requestedTab);
+    let browser = tab.linkedBrowser;
+    if (browser) {
+      browser.preserveLayers(false);
+    }
+    this.setTabState(tab, this.STATE_UNLOADING);
+  }
+
+  evictOldestTabFromCache() {
+    let tab = this.tabLayerCache.shift();
+    this.cleanUpTabAfterEviction(tab);
+  }
+
+  maybePromoteTabInLayerCache(tab) {
+    if (
+      lazy.gTabCacheSize > 1 &&
+      tab.linkedBrowser.isRemoteBrowser &&
+      tab.linkedBrowser.currentURI.spec != "about:blank"
+    ) {
+      let tabIndex = this.tabLayerCache.indexOf(tab);
+
+      if (tabIndex != -1) {
+        this.tabLayerCache.splice(tabIndex, 1);
+      }
+
+      this.tabLayerCache.push(tab);
+
+      if (this.tabLayerCache.length > lazy.gTabCacheSize) {
+        this.evictOldestTabFromCache();
+      }
+    }
+  }
+
+  // Called when the user asks to switch to a given tab.
+  requestTab(tab) {
+    if (tab === this.requestedTab) {
+      return;
+    }
+
+    let tabState = this.getTabState(tab);
+    this.noteTabRequested(tab, tabState);
+
+    this.logState("requestTab " + this.tinfo(tab));
+    this.startTabSwitch();
+
+    let oldBrowser = this.requestedTab.linkedBrowser;
+    oldBrowser.deprioritize();
+    this.requestedTab = tab;
+    if (tabState == this.STATE_LOADED) {
+      this.maybeVisibleTabs.clear();
+    }
+
+    tab.linkedBrowser.setAttribute("primary", "true");
+    if (this.lastPrimaryTab && this.lastPrimaryTab != tab) {
+      this.lastPrimaryTab.linkedBrowser.removeAttribute("primary");
+    }
+    this.lastPrimaryTab = tab;
+
+    this.queueUnload(this.UNLOAD_DELAY);
+  }
+
+  queueUnload(unloadTimeout) {
+    this.handleEvent({ type: "queueUnload", unloadTimeout });
+  }
+
+  onQueueUnload(unloadTimeout) {
+    if (this.unloadTimer) {
+      this.clearTimer(this.unloadTimer);
+    }
+    this.unloadTimer = this.setTimer(
+      () => this.handleEvent({ type: "unloadTimeout" }),
+      unloadTimeout
+    );
+  }
+
+  handleEvent(event, delayed = false) {
+    if (this._processing) {
+      this.setTimer(() => this.handleEvent(event, true), 0);
+      return;
+    }
+    if (delayed && this.tabbrowser._switcher != this) {
+      // if we delayed processing this event, we might be out of date, in which
+      // case we drop the delayed events
+      return;
+    }
+    this._processing = true;
+    try {
+      this.preActions();
+
+      switch (event.type) {
+        case "queueUnload":
+          this.onQueueUnload(event.unloadTimeout);
+          break;
+        case "unloadTimeout":
+          this.onUnloadTimeout();
+          break;
+        case "loadTimeout":
+          this.onLoadTimeout();
+          break;
+        case "tabRemoved":
+          this.onTabRemovedImpl(event.tab);
+          break;
+        case "MozLayerTreeReady": {
+          let browser = event.originalTarget;
+          if (!browser.renderLayers) {
+            // By the time we handle this event, it's possible that something
+            // else has already set renderLayers to false, in which case this
+            // event is stale and we can safely ignore it.
+            return;
+          }
+          this.onLayersReady(browser);
+          break;
+        }
+        case "MozAfterPaint":
+          this.onPaint(event);
+          break;
+        case "MozLayerTreeCleared": {
+          let browser = event.originalTarget;
+          if (browser.renderLayers) {
+            // By the time we handle this event, it's possible that something
+            // else has already set renderLayers to true, in which case this
+            // event is stale and we can safely ignore it.
+            return;
+          }
+          this.onLayersCleared(browser);
+          break;
+        }
+        case "TabRemotenessChange":
+          this.onRemotenessChange(event.target);
+          break;
+        case "visibilitychange":
+          this.onVisibilityChange();
+          break;
+        case "SwapDocShells":
+          this.onSwapDocShells(event.originalTarget, event.detail);
+          break;
+        case "EndSwapDocShells":
+          this.onEndSwapDocShells(event.originalTarget, event.detail);
+          break;
+      }
+
+      this.postActions(event.type);
+    } finally {
+      this._processing = false;
+    }
+  }
+
+  /*
+   * Telemetry and Profiler related helpers for recording tab switch
+   * timing.
+   */
+
+  startTabSwitch() {
+    this.noteStartTabSwitch();
+    this.switchInProgress = true;
+  }
+
+  /**
+   * Something has occurred that might mean that we've completed
+   * the tab switch (layers are ready, paints are done, spinners
+   * are hidden). This checks to make sure all conditions are
+   * satisfied, and then records the tab switch as finished.
+   */
+  maybeFinishTabSwitch() {
+    if (
+      this.switchInProgress &&
+      this.requestedTab &&
+      (this.getTabState(this.requestedTab) == this.STATE_LOADED ||
+        this.requestedTab === this.blankTab)
+    ) {
+      if (this.requestedTab !== this.blankTab) {
+        this.maybePromoteTabInLayerCache(this.requestedTab);
+      }
+
+      this.noteFinishTabSwitch();
+      this.switchInProgress = false;
+
+      let event = new this.window.CustomEvent("TabSwitched", {
+        bubbles: true,
+        detail: {
+          tab: this.requestedTab,
+        },
+      });
+      this.tabbrowser.dispatchEvent(event);
+    }
+  }
+
+  /*
+   * Debug related logging for switcher.
+   */
+  logging() {
+    if (this._useDumpForLogging) {
+      return true;
+    }
+    if (this._logInit) {
+      return this._shouldLog;
+    }
+    let result = Services.prefs.getBoolPref(
+      "browser.tabs.remote.logSwitchTiming",
+      false
+    );
+    this._shouldLog = result;
+    this._logInit = true;
+    return this._shouldLog;
+  }
+
+  tinfo(tab) {
+    if (tab) {
+      return tab._tPos + "(" + tab.linkedBrowser.currentURI.spec + ")";
+    }
+    return "null";
+  }
+
+  log(s) {
+    if (!this.logging()) {
+      return;
+    }
+    if (this._useDumpForLogging) {
+      dump(s + "\n");
+    } else {
+      Services.console.logStringMessage(s);
+    }
+  }
+
+  addLogFlag(flag, ...subFlags) {
+    if (this.logging()) {
+      if (subFlags.length) {
+        flag += `(${subFlags.map(f => (f ? 1 : 0)).join("")})`;
+      }
+      this._logFlags.push(flag);
+    }
+  }
+
+  logState(suffix) {
+    if (!this.logging()) {
+      return;
+    }
+
+    let getTabString = tab => {
+      let tabString = "";
+
+      let state = this.getTabState(tab);
+      let isWarming = this.warmingTabs.has(tab);
+      let isCached = this.tabLayerCache.includes(tab);
+      let isClosing = tab.closing;
+      let linkedBrowser = tab.linkedBrowser;
+      let isActive = linkedBrowser && linkedBrowser.docShellIsActive;
+      let isRendered = linkedBrowser && linkedBrowser.renderLayers;
+      let isPiP =
+        linkedBrowser &&
+        lazy.PictureInPicture.isOriginatingBrowser(linkedBrowser);
+
+      if (tab === this.lastVisibleTab) {
+        tabString += "V";
+      }
+      if (tab === this.loadingTab) {
+        tabString += "L";
+      }
+      if (tab === this.requestedTab) {
+        tabString += "R";
+      }
+      if (tab === this.blankTab) {
+        tabString += "B";
+      }
+      if (this.maybeVisibleTabs.has(tab)) {
+        tabString += "M";
+      }
+
+      let extraStates = "";
+      if (isWarming) {
+        extraStates += "W";
+      }
+      if (isCached) {
+        extraStates += "C";
+      }
+      if (isClosing) {
+        extraStates += "X";
+      }
+      if (isActive) {
+        extraStates += "A";
+      }
+      if (isRendered) {
+        extraStates += "R";
+      }
+      if (isPiP) {
+        extraStates += "P";
+      }
+      if (extraStates != "") {
+        tabString += `(${extraStates})`;
+      }
+
+      switch (state) {
+        case this.STATE_LOADED: {
+          tabString += "(loaded)";
+          break;
+        }
+        case this.STATE_LOADING: {
+          tabString += "(loading)";
+          break;
+        }
+        case this.STATE_UNLOADING: {
+          tabString += "(unloading)";
+          break;
+        }
+        case this.STATE_UNLOADED: {
+          tabString += "(unloaded)";
+          break;
+        }
+      }
+
+      return tabString;
+    };
+
+    let accum = "";
+
+    // This is a bit tricky to read, but what we're doing here is collapsing
+    // identical tab states down to make the overal string shorter and easier
+    // to read, and we move all simply unloaded tabs to the back of the list.
+    // I.e., we turn
+    //   "0:(unloaded) 1:(unloaded) 2:(unloaded) 3:(loaded)""
+    // into
+    //   "3:(loaded) 0...2:(unloaded)"
+    let tabStrings = this.tabbrowser.tabs.map(t => getTabString(t));
+    let lastMatch = -1;
+    let unloadedTabsStrings = [];
+    for (let i = 0; i <= tabStrings.length; i++) {
+      if (i > 0) {
+        if (i < tabStrings.length && tabStrings[i] == tabStrings[lastMatch]) {
+          continue;
+        }
+
+        if (tabStrings[lastMatch] == "(unloaded)") {
+          if (lastMatch == i - 1) {
+            unloadedTabsStrings.push(lastMatch.toString());
+          } else {
+            unloadedTabsStrings.push(`${lastMatch}...${i - 1}`);
+          }
+        } else if (lastMatch == i - 1) {
+          accum += `${lastMatch}:${tabStrings[lastMatch]} `;
+        } else {
+          accum += `${lastMatch}...${i - 1}:${tabStrings[lastMatch]} `;
+        }
+      }
+
+      lastMatch = i;
+    }
+
+    if (unloadedTabsStrings.length) {
+      accum += `${unloadedTabsStrings.join(",")}:(unloaded) `;
+    }
+
+    accum += "cached: " + this.tabLayerCache.length + " ";
+
+    if (this._logFlags.length) {
+      accum += `[${this._logFlags.join(",")}] `;
+      this._logFlags = [];
+    }
+
+    // It can be annoying to read through the entirety of a log string just
+    // to check if something changed or not. So if we can tell that nothing
+    // changed, just write "unchanged" to save the reader's time.
+    let logString;
+    if (this._lastLogString == accum) {
+      accum = "unchanged";
+    } else {
+      this._lastLogString = accum;
+    }
+    logString = `ATS: ${accum}{${suffix}}`;
+
+    if (this._useDumpForLogging) {
+      dump(logString + "\n");
+    } else {
+      Services.console.logStringMessage(logString);
+    }
+  }
+
+  noteMakingTabVisibleWithoutLayers() {
+    // We're making the tab visible even though we haven't yet got layers for it.
+    // It's hard to know which composite the layers will first be available in (and
+    // the parent process might not even get MozAfterPaint delivered for it), so just
+    // give up measuring this for now. :(
+    Glean.performanceInteraction.tabSwitchComposite.cancel(
+      this._tabswitchTimerId
+    );
+    this._tabswitchTimerId = null;
+  }
+
+  notePaint(event) {
+    if (this.switchPaintId != -1 && event.transactionId >= this.switchPaintId) {
+      if (this._tabswitchTimerId) {
+        Glean.performanceInteraction.tabSwitchComposite.stopAndAccumulate(
+          this._tabswitchTimerId
+        );
+        this._tabswitchTimerId = null;
+      }
+      let { innerWindowId } = this.window.windowGlobalChild;
+      ChromeUtils.addProfilerMarker("AsyncTabSwitch:Composited", {
+        innerWindowId,
+      });
+      this.switchPaintId = -1;
+    }
+  }
+
+  noteTabRequested(tab, tabState) {
+    if (lazy.gTabWarmingEnabled) {
+      let warmingState = "disqualified";
+
+      if (this.canWarmTab(tab)) {
+        if (tabState == this.STATE_LOADING) {
+          warmingState = "stillLoading";
+        } else if (tabState == this.STATE_LOADED) {
+          warmingState = "loaded";
+        } else if (
+          tabState == this.STATE_UNLOADING ||
+          tabState == this.STATE_UNLOADED
+        ) {
+          // At this point, if the tab's browser was being inserted
+          // lazily, we never had a chance to warm it up, and unfortunately
+          // there's no great way to detect that case. Those cases will
+          // end up in the "notWarmed" bucket, along with legitimate cases
+          // where tabs could have been warmed but weren't.
+          warmingState = "notWarmed";
+        }
+      }
+
+      Services.telemetry
+        .getHistogramById("FX_TAB_SWITCH_REQUEST_TAB_WARMING_STATE")
+        .add(warmingState);
+    }
+  }
+
+  noteStartTabSwitch() {
+    TelemetryStopwatch.cancel("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
+    TelemetryStopwatch.start("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
+
+    if (this._tabswitchTimerId) {
+      Glean.performanceInteraction.tabSwitchComposite.cancel(
+        this._tabswitchTimerId
+      );
+    }
+    this._tabswitchTimerId =
+      Glean.performanceInteraction.tabSwitchComposite.start();
+    let { innerWindowId } = this.window.windowGlobalChild;
+    ChromeUtils.addProfilerMarker("AsyncTabSwitch:Start", { innerWindowId });
+  }
+
+  noteFinishTabSwitch() {
+    // After this point the tab has switched from the content thread's point of view.
+    // The changes will be visible after the next refresh driver tick + composite.
+    let time = TelemetryStopwatch.timeElapsed(
+      "FX_TAB_SWITCH_TOTAL_E10S_MS",
+      this.window
+    );
+    if (time != -1) {
+      TelemetryStopwatch.finish("FX_TAB_SWITCH_TOTAL_E10S_MS", this.window);
+      this.log("DEBUG: tab switch time = " + time);
+      let { innerWindowId } = this.window.windowGlobalChild;
+      ChromeUtils.addProfilerMarker("AsyncTabSwitch:Finish", { innerWindowId });
+    }
+  }
+
+  noteSpinnerDisplayed() {
+    this.assert(!this.spinnerTab);
+    let browser = this.requestedTab.linkedBrowser;
+    this.assert(browser.isRemoteBrowser);
+    TelemetryStopwatch.start("FX_TAB_SWITCH_SPINNER_VISIBLE_MS", this.window);
+    // We have a second, similar probe for capturing recordings of
+    // when the spinner is displayed for very long periods.
+    TelemetryStopwatch.start(
+      "FX_TAB_SWITCH_SPINNER_VISIBLE_LONG_MS",
+      this.window
+    );
+    let { innerWindowId } = this.window.windowGlobalChild;
+    ChromeUtils.addProfilerMarker("AsyncTabSwitch:SpinnerShown", {
+      innerWindowId,
+    });
+    Services.telemetry
+      .getHistogramById("FX_TAB_SWITCH_SPINNER_VISIBLE_TRIGGER")
+      .add(this._loadTimerClearedBy);
+    if (AppConstants.NIGHTLY_BUILD) {
+      Services.obs.notifyObservers(null, "tabswitch-spinner");
+    }
+  }
+
+  noteSpinnerHidden() {
+    this.assert(this.spinnerTab);
+    this.log(
+      "DEBUG: spinner time = " +
+        TelemetryStopwatch.timeElapsed(
+          "FX_TAB_SWITCH_SPINNER_VISIBLE_MS",
+          this.window
+        )
+    );
+    TelemetryStopwatch.finish("FX_TAB_SWITCH_SPINNER_VISIBLE_MS", this.window);
+    TelemetryStopwatch.finish(
+      "FX_TAB_SWITCH_SPINNER_VISIBLE_LONG_MS",
+      this.window
+    );
+    let { innerWindowId } = this.window.windowGlobalChild;
+    ChromeUtils.addProfilerMarker("AsyncTabSwitch:SpinnerHidden", {
+      innerWindowId,
+    });
+    // we do not get a onPaint after displaying the spinner
+    this._loadTimerClearedBy = "none";
+  }
+}
diff --git a/browser/modules/BackgroundTask_install.sys.mjs b/browser/modules/BackgroundTask_install.sys.mjs
new file mode 100644
index 0000000000..8f13aa8789
--- /dev/null
+++ b/browser/modules/BackgroundTask_install.sys.mjs
@@ -0,0 +1,29 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * 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/. */
+
+/**
+ * This task ought to have an ephemeral profile and should not apply updates.
+ * These settings are controlled externally, by
+ * `BackgroundTasks::IsUpdatingTaskName` and
+ * `BackgroundTasks::IsEphemeralProfileTaskName`.
+ */
+
+// This happens synchronously during installation. It shouldn't take that long
+// and if something goes wrong we really don't want to sit around waiting for
+// it.
+export const backgroundTaskTimeoutSec = 30;
+
+export async function runBackgroundTask(commandLine) {
+  console.log("Running BackgroundTask_install.");
+
+  console.log("Cleaning up update files.");
+  try {
+    Cc["@mozilla.org/updates/update-manager;1"]
+      .getService(Ci.nsIUpdateManager)
+      .doInstallCleanup();
+  } catch (ex) {
+    console.error(ex);
+  }
+}
diff --git a/browser/modules/BackgroundTask_uninstall.sys.mjs b/browser/modules/BackgroundTask_uninstall.sys.mjs
new file mode 100644
index 0000000000..9e51248438
--- /dev/null
+++ b/browser/modules/BackgroundTask_uninstall.sys.mjs
@@ -0,0 +1,58 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+ * 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/. */
+
+/**
+ * This task ought to have an ephemeral profile and should not apply updates.
+ * These settings are controlled externally, by
+ * `BackgroundTasks::IsUpdatingTaskName` and
+ * `BackgroundTasks::IsEphemeralProfileTaskName`.
+ */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+export async function runBackgroundTask(commandLine) {
+  console.log("Running BackgroundTask_uninstall.");
+
+  if (AppConstants.platform === "win") {
+    try {
+      removeNotifications();
+    } catch (ex) {
+      console.error(ex);
+    }
+  } else {
+    console.log("Not a Windows install. Skipping notification removal.");
+  }
+
+  console.log("Cleaning up update files.");
+  try {
+    Cc["@mozilla.org/updates/update-manager;1"]
+      .getService(Ci.nsIUpdateManager)
+      .doUninstallCleanup();
+  } catch (ex) {
+    console.error(ex);
+  }
+}
+
+function removeNotifications() {
+  console.log("Removing Windows toast notifications.");
+
+  if (!("nsIWindowsAlertsService" in Ci)) {
+    console.log("nsIWindowsAlertsService not present.");
+    return;
+  }
+
+  let alertsService;
+  try {
+    alertsService = Cc["@mozilla.org/system-alerts-service;1"]
+      .getService(Ci.nsIAlertsService)
+      .QueryInterface(Ci.nsIWindowsAlertsService);
+  } catch (e) {
+    console.error("Error retrieving nsIWindowsAlertsService: " + e.message);
+    return;
+  }
+
+  alertsService.removeAllNotificationsForInstall();
+  console.log("Finished removing Windows toast notifications.");
+}
diff --git a/browser/modules/BrowserUIUtils.sys.mjs b/browser/modules/BrowserUIUtils.sys.mjs
new file mode 100644
index 0000000000..98e81c6d55
--- /dev/null
+++ b/browser/modules/BrowserUIUtils.sys.mjs
@@ -0,0 +1,180 @@
+/* -*- mode: js; indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "trimHttps",
+  "browser.urlbar.trimHttps"
+);
+export var BrowserUIUtils = {
+  /**
+   * Check whether a page can be considered as 'empty', that its URI
+   * reflects its origin, and that if it's loaded in a tab, that tab
+   * could be considered 'empty' (e.g. like the result of opening
+   * a 'blank' new tab).
+   *
+   * We have to do more than just check the URI, because especially
+   * for things like about:blank, it is possible that the opener or
+   * some other page has control over the contents of the page.
+   *
+   * @param {Browser} browser
+   *        The browser whose page we're checking.
+   * @param {nsIURI} [uri]
+   *        The URI against which we're checking (the browser's currentURI
+   *        if omitted).
+   *
+   * @return {boolean} false if the page was opened by or is controlled by
+   *         arbitrary web content, unless that content corresponds with the URI.
+   *         true if the page is blank and controlled by a principal matching
+   *         that URI (or the system principal if the principal has no URI)
+   */
+  checkEmptyPageOrigin(browser, uri = browser.currentURI) {
+    // If another page opened this page with e.g. window.open, this page might
+    // be controlled by its opener.
+    if (browser.hasContentOpener) {
+      return false;
+    }
+    let contentPrincipal = browser.contentPrincipal;
+    // Not all principals have URIs...
+    // There are two special-cases involving about:blank. One is where
+    // the user has manually loaded it and it got created with a null
+    // principal. The other involves the case where we load
+    // some other empty page in a browser and the current page is the
+    // initial about:blank page (which has that as its principal, not
+    // just URI in which case it could be web-based). Especially in
+    // e10s, we need to tackle that case specifically to avoid race
+    // conditions when updating the URL bar.
+    //
+    // Note that we check the documentURI here, since the currentURI on
+    // the browser might have been set by SessionStore in order to
+    // support switch-to-tab without having actually loaded the content
+    // yet.
+    let uriToCheck = browser.documentURI || uri;
+    if (
+      (uriToCheck.spec == "about:blank" && contentPrincipal.isNullPrincipal) ||
+      contentPrincipal.spec == "about:blank"
+    ) {
+      return true;
+    }
+    if (contentPrincipal.isContentPrincipal) {
+      return contentPrincipal.equalsURI(uri);
+    }
+    // ... so for those that don't have them, enforce that the page has the
+    // system principal (this matches e.g. on about:newtab).
+    return contentPrincipal.isSystemPrincipal;
+  },
+
+  /**
+   * Generate a document fragment for a localized string that has DOM
+   * node replacements. This avoids using getFormattedString followed
+   * by assigning to innerHTML. Fluent can probably replace this when
+   * it is in use everywhere.
+   *
+   * @param {Document} doc
+   * @param {String}   msg
+   *                   The string to put replacements in. Fetch from
+   *                   a stringbundle using getString or GetStringFromName,
+   *                   or even an inserted dtd string.
+   * @param {Node|String} nodesOrStrings
+   *                   The replacement items. Can be a mix of Nodes
+   *                   and Strings. However, for correct behaviour, the
+   *                   number of items provided needs to exactly match
+   *                   the number of replacement strings in the l10n string.
+   * @returns {DocumentFragment}
+   *                   A document fragment. In the trivial case (no
+   *                   replacements), this will simply be a fragment with 1
+   *                   child, a text node containing the localized string.
+   */
+  getLocalizedFragment(doc, msg, ...nodesOrStrings) {
+    // Ensure replacement points are indexed:
+    for (let i = 1; i <= nodesOrStrings.length; i++) {
+      if (!msg.includes("%" + i + "$S")) {
+        msg = msg.replace(/%S/, "%" + i + "$S");
+      }
+    }
+    let numberOfInsertionPoints = msg.match(/%\d+\$S/g).length;
+    if (numberOfInsertionPoints != nodesOrStrings.length) {
+      console.error(
+        `Message has ${numberOfInsertionPoints} insertion points, ` +
+          `but got ${nodesOrStrings.length} replacement parameters!`
+      );
+    }
+
+    let fragment = doc.createDocumentFragment();
+    let parts = [msg];
+    let insertionPoint = 1;
+    for (let replacement of nodesOrStrings) {
+      let insertionString = "%" + insertionPoint++ + "$S";
+      let partIndex = parts.findIndex(
+        part => typeof part == "string" && part.includes(insertionString)
+      );
+      if (partIndex == -1) {
+        fragment.appendChild(doc.createTextNode(msg));
+        return fragment;
+      }
+
+      if (typeof replacement == "string") {
+        parts[partIndex] = parts[partIndex].replace(
+          insertionString,
+          replacement
+        );
+      } else {
+        let [firstBit, lastBit] = parts[partIndex].split(insertionString);
+        parts.splice(partIndex, 1, firstBit, replacement, lastBit);
+      }
+    }
+
+    // Put everything in a document fragment:
+    for (let part of parts) {
+      if (typeof part == "string") {
+        if (part) {
+          fragment.appendChild(doc.createTextNode(part));
+        }
+      } else {
+        fragment.appendChild(part);
+      }
+    }
+    return fragment;
+  },
+
+  removeSingleTrailingSlashFromURL(aURL) {
+    // remove single trailing slash for http/https/ftp URLs
+    return aURL.replace(/^((?:http|https|ftp):\/\/[^/]+)\/$/, "$1");
+  },
+
+  get trimURLProtocol() {
+    return lazy.trimHttps ? "https://" : "http://";
+  },
+
+  /**
+   * Returns a URL which has been trimmed by removing 'http://' or 'https://',
+   * when the pref 'trimHttps' is set to true, and any trailing slash
+   * (in http/https/ftp urls). Note that a trimmed url may not load the same
+   * page as the original url, so before loading it, it must be passed through
+   * URIFixup, to check trimming doesn't change its destination. We don't run
+   * the URIFixup check here, because trimURL is in the page load path
+   * (see onLocationChange), so it must be fast and simple.
+   *
+   * @param {string} aURL The URL to trim.
+   * @returns {string} The trimmed string.
+   */
+  trimURL(aURL) {
+    let url = this.removeSingleTrailingSlashFromURL(aURL);
+    return url.startsWith(this.trimURLProtocol)
+      ? url.substring(this.trimURLProtocol.length)
+      : url;
+  },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  BrowserUIUtils,
+  "quitShortcutDisabled",
+  "browser.quitShortcut.disabled",
+  false
+);
diff --git a/browser/modules/BrowserUsageTelemetry.sys.mjs b/browser/modules/BrowserUsageTelemetry.sys.mjs
new file mode 100644
index 0000000000..607ed4e31d
--- /dev/null
+++ b/browser/modules/BrowserUsageTelemetry.sys.mjs
@@ -0,0 +1,1427 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ClientID: "resource://gre/modules/ClientID.sys.mjs",
+  CustomizableUI: "resource:///modules/CustomizableUI.sys.mjs",
+  DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs",
+  PageActions: "resource:///modules/PageActions.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  SearchSERPTelemetry: "resource:///modules/SearchSERPTelemetry.sys.mjs",
+  SearchSERPTelemetryUtils: "resource:///modules/SearchSERPTelemetry.sys.mjs",
+
+  WindowsInstallsInfo:
+    "resource://gre/modules/components-utils/WindowsInstallsInfo.sys.mjs",
+
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+// This pref is in seconds!
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gRecentVisitedOriginsExpiry",
+  "browser.engagement.recent_visited_origins.expiry"
+);
+
+// The upper bound for the count of the visited unique domain names.
+const MAX_UNIQUE_VISITED_DOMAINS = 100;
+
+// Observed topic names.
+const TAB_RESTORING_TOPIC = "SSTabRestoring";
+const TELEMETRY_SUBSESSIONSPLIT_TOPIC =
+  "internal-telemetry-after-subsession-split";
+const DOMWINDOW_OPENED_TOPIC = "domwindowopened";
+
+// Probe names.
+const MAX_TAB_COUNT_SCALAR_NAME = "browser.engagement.max_concurrent_tab_count";
+const MAX_WINDOW_COUNT_SCALAR_NAME =
+  "browser.engagement.max_concurrent_window_count";
+const TAB_OPEN_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.tab_open_event_count";
+const MAX_TAB_PINNED_COUNT_SCALAR_NAME =
+  "browser.engagement.max_concurrent_tab_pinned_count";
+const TAB_PINNED_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.tab_pinned_event_count";
+const WINDOW_OPEN_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.window_open_event_count";
+const UNIQUE_DOMAINS_COUNT_SCALAR_NAME =
+  "browser.engagement.unique_domains_count";
+const TOTAL_URI_COUNT_SCALAR_NAME = "browser.engagement.total_uri_count";
+const UNFILTERED_URI_COUNT_SCALAR_NAME =
+  "browser.engagement.unfiltered_uri_count";
+const TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE_SCALAR_NAME =
+  "browser.engagement.total_uri_count_normal_and_private_mode";
+
+export const MINIMUM_TAB_COUNT_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes, in ms
+
+// The elements we consider to be interactive.
+const UI_TARGET_ELEMENTS = [
+  "menuitem",
+  "toolbarbutton",
+  "key",
+  "command",
+  "checkbox",
+  "input",
+  "button",
+  "image",
+  "radio",
+  "richlistitem",
+];
+
+// The containers of interactive elements that we care about and their pretty
+// names. These should be listed in order of most-specific to least-specific,
+// when iterating JavaScript will guarantee that ordering and so we will find
+// the most specific area first.
+const BROWSER_UI_CONTAINER_IDS = {
+  "toolbar-menubar": "menu-bar",
+  TabsToolbar: "tabs-bar",
+  PersonalToolbar: "bookmarks-bar",
+  "appMenu-popup": "app-menu",
+  tabContextMenu: "tabs-context",
+  contentAreaContextMenu: "content-context",
+  "widget-overflow-list": "overflow-menu",
+  "widget-overflow-fixed-list": "pinned-overflow-menu",
+  "page-action-buttons": "pageaction-urlbar",
+  pageActionPanel: "pageaction-panel",
+  "unified-extensions-area": "unified-extensions-area",
+  "allTabsMenu-allTabsView": "alltabs-menu",
+
+  // This should appear last as some of the above are inside the nav bar.
+  "nav-bar": "nav-bar",
+};
+
+const ENTRYPOINT_TRACKED_CONTEXT_MENU_IDS = {
+  [BROWSER_UI_CONTAINER_IDS.tabContextMenu]: "tabs-context-entrypoint",
+};
+
+// A list of the expected panes in about:preferences
+const PREFERENCES_PANES = [
+  "paneHome",
+  "paneGeneral",
+  "panePrivacy",
+  "paneSearch",
+  "paneSearchResults",
+  "paneSync",
+  "paneContainers",
+  "paneExperimental",
+  "paneMoreFromMozilla",
+];
+
+const IGNORABLE_EVENTS = new WeakMap();
+
+const KNOWN_ADDONS = [];
+
+// Buttons that, when clicked, set a preference to true. The convention
+// is that the preference is named:
+//
+// browser.engagement.<button id>.has-used
+//
+// and is defaulted to false.
+const SET_USAGE_PREF_BUTTONS = [
+  "downloads-button",
+  "fxa-toolbar-menu-button",
+  "home-button",
+  "sidebar-button",
+  "library-button",
+];
+
+// Buttons that, when clicked, increase a counter. The convention
+// is that the preference is named:
+//
+// browser.engagement.<button id>.used-count
+//
+// and doesn't have a default value.
+const SET_USAGECOUNT_PREF_BUTTONS = [
+  "pageAction-panel-copyURL",
+  "pageAction-panel-emailLink",
+  "pageAction-panel-pinTab",
+  "pageAction-panel-screenshots_mozilla_org",
+  "pageAction-panel-shareURL",
+];
+
+// Places context menu IDs.
+const PLACES_CONTEXT_MENU_ID = "placesContext";
+const PLACES_OPEN_IN_CONTAINER_TAB_MENU_ID =
+  "placesContext_open:newcontainertab";
+
+// Commands used to open history or bookmark links from places context menu.
+const PLACES_OPEN_COMMANDS = [
+  "placesCmd_open",
+  "placesCmd_open:window",
+  "placesCmd_open:privatewindow",
+  "placesCmd_open:tab",
+];
+
+function telemetryId(widgetId, obscureAddons = true) {
+  // Add-on IDs need to be obscured.
+  function addonId(id) {
+    if (!obscureAddons) {
+      return id;
+    }
+
+    let pos = KNOWN_ADDONS.indexOf(id);
+    if (pos < 0) {
+      pos = KNOWN_ADDONS.length;
+      KNOWN_ADDONS.push(id);
+    }
+    return `addon${pos}`;
+  }
+
+  if (widgetId.endsWith("-browser-action")) {
+    widgetId = addonId(
+      widgetId.substring(0, widgetId.length - "-browser-action".length)
+    );
+  } else if (widgetId.startsWith("pageAction-")) {
+    let actionId;
+    if (widgetId.startsWith("pageAction-urlbar-")) {
+      actionId = widgetId.substring("pageAction-urlbar-".length);
+    } else if (widgetId.startsWith("pageAction-panel-")) {
+      actionId = widgetId.substring("pageAction-panel-".length);
+    }
+
+    if (actionId) {
+      let action = lazy.PageActions.actionForID(actionId);
+      widgetId = action?._isMozillaAction ? actionId : addonId(actionId);
+    }
+  } else if (widgetId.startsWith("ext-keyset-id-")) {
+    // Webextension command shortcuts don't have an id on their key element so
+    // we see the id from the keyset that contains them.
+    widgetId = addonId(widgetId.substring("ext-keyset-id-".length));
+  } else if (widgetId.startsWith("ext-key-id-")) {
+    // The command for a webextension sidebar action is an exception to the above rule.
+    widgetId = widgetId.substring("ext-key-id-".length);
+    if (widgetId.endsWith("-sidebar-action")) {
+      widgetId = addonId(
+        widgetId.substring(0, widgetId.length - "-sidebar-action".length)
+      );
+    }
+  }
+
+  return widgetId.replace(/_/g, "-");
+}
+
+function getOpenTabsAndWinsCounts() {
+  let loadedTabCount = 0;
+  let tabCount = 0;
+  let winCount = 0;
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    winCount++;
+    tabCount += win.gBrowser.tabs.length;
+    for (const tab of win.gBrowser.tabs) {
+      if (tab.getAttribute("pending") !== "true") {
+        loadedTabCount += 1;
+      }
+    }
+  }
+
+  return { loadedTabCount, tabCount, winCount };
+}
+
+function getPinnedTabsCount() {
+  let pinnedTabs = 0;
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    pinnedTabs += [...win.ownerGlobal.gBrowser.tabs].filter(
+      t => t.pinned
+    ).length;
+  }
+
+  return pinnedTabs;
+}
+
+export let URICountListener = {
+  // A set containing the visited domains, see bug 1271310.
+  _domainSet: new Set(),
+  // A set containing the visited origins during the last 24 hours (similar to domains, but not quite the same)
+  _domain24hrSet: new Set(),
+  // A map to keep track of the URIs loaded from the restored tabs.
+  _restoredURIsMap: new WeakMap(),
+  // Ongoing expiration timeouts.
+  _timeouts: new Set(),
+
+  isHttpURI(uri) {
+    // Only consider http(s) schemas.
+    return uri.schemeIs("http") || uri.schemeIs("https");
+  },
+
+  addRestoredURI(browser, uri) {
+    if (!this.isHttpURI(uri)) {
+      return;
+    }
+
+    this._restoredURIsMap.set(browser, uri.spec);
+  },
+
+  onLocationChange(browser, webProgress, request, uri, flags) {
+    if (
+      !(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT) &&
+      webProgress.isTopLevel
+    ) {
+      // By default, assume we no longer need to track this tab.
+      lazy.SearchSERPTelemetry.stopTrackingBrowser(
+        browser,
+        lazy.SearchSERPTelemetryUtils.ABANDONMENTS.NAVIGATION
+      );
+    }
+
+    // Don't count this URI if it's an error page.
+    if (flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) {
+      return;
+    }
+
+    // We only care about top level loads.
+    if (!webProgress.isTopLevel) {
+      return;
+    }
+
+    // The SessionStore sets the URI of a tab first, firing onLocationChange the
+    // first time, then manages content loading using its scheduler. Once content
+    // loads, we will hit onLocationChange again.
+    // We can catch the first case by checking for null requests: be advised that
+    // this can also happen when navigating page fragments, so account for it.
+    if (
+      !request &&
+      !(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)
+    ) {
+      return;
+    }
+
+    // Don't include URI and domain counts when in private mode.
+    let shouldCountURI =
+      !lazy.PrivateBrowsingUtils.isWindowPrivate(browser.ownerGlobal) ||
+      Services.prefs.getBoolPref(
+        "browser.engagement.total_uri_count.pbm",
+        false
+      );
+
+    // Track URI loads, even if they're not http(s).
+    let uriSpec = null;
+    try {
+      uriSpec = uri.spec;
+    } catch (e) {
+      // If we have troubles parsing the spec, still count this as
+      // an unfiltered URI.
+      if (shouldCountURI) {
+        Services.telemetry.scalarAdd(UNFILTERED_URI_COUNT_SCALAR_NAME, 1);
+      }
+      return;
+    }
+
+    // Don't count about:blank and similar pages, as they would artificially
+    // inflate the counts.
+    if (browser.ownerGlobal.gInitialPages.includes(uriSpec)) {
+      return;
+    }
+
+    // If the URI we're loading is in the _restoredURIsMap, then it comes from a
+    // restored tab. If so, let's skip it and remove it from the map as we want to
+    // count page refreshes.
+    if (this._restoredURIsMap.get(browser) === uriSpec) {
+      this._restoredURIsMap.delete(browser);
+      return;
+    }
+
+    // The URI wasn't from a restored tab. Count it among the unfiltered URIs.
+    // If this is an http(s) URI, this also gets counted by the "total_uri_count"
+    // probe.
+    if (shouldCountURI) {
+      Services.telemetry.scalarAdd(UNFILTERED_URI_COUNT_SCALAR_NAME, 1);
+    }
+
+    if (!this.isHttpURI(uri)) {
+      return;
+    }
+
+    if (!(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)) {
+      lazy.SearchSERPTelemetry.updateTrackingStatus(
+        browser,
+        uriSpec,
+        webProgress.loadType
+      );
+    } else {
+      lazy.SearchSERPTelemetry.updateTrackingSinglePageApp(
+        browser,
+        uriSpec,
+        webProgress.loadType,
+        flags
+      );
+    }
+
+    // Update total URI count, including when in private mode.
+    Services.telemetry.scalarAdd(
+      TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE_SCALAR_NAME,
+      1
+    );
+    Glean.browserEngagement.uriCount.add(1);
+
+    if (!shouldCountURI) {
+      return;
+    }
+
+    // Update the URI counts.
+    Services.telemetry.scalarAdd(TOTAL_URI_COUNT_SCALAR_NAME, 1);
+
+    // Update tab count
+    BrowserUsageTelemetry._recordTabCounts(getOpenTabsAndWinsCounts());
+
+    // Unique domains should be aggregated by (eTLD + 1): x.test.com and y.test.com
+    // are counted once as test.com.
+    let baseDomain;
+    try {
+      // Even if only considering http(s) URIs, |getBaseDomain| could still throw
+      // due to the URI containing invalid characters or the domain actually being
+      // an ipv4 or ipv6 address.
+      baseDomain = Services.eTLD.getBaseDomain(uri);
+    } catch (e) {
+      return;
+    }
+
+    // We only want to count the unique domains up to MAX_UNIQUE_VISITED_DOMAINS.
+    if (this._domainSet.size < MAX_UNIQUE_VISITED_DOMAINS) {
+      this._domainSet.add(baseDomain);
+      Services.telemetry.scalarSet(
+        UNIQUE_DOMAINS_COUNT_SCALAR_NAME,
+        this._domainSet.size
+      );
+    }
+
+    this._domain24hrSet.add(baseDomain);
+    if (lazy.gRecentVisitedOriginsExpiry) {
+      let timeoutId = lazy.setTimeout(() => {
+        this._domain24hrSet.delete(baseDomain);
+        this._timeouts.delete(timeoutId);
+      }, lazy.gRecentVisitedOriginsExpiry * 1000);
+      this._timeouts.add(timeoutId);
+    }
+  },
+
+  /**
+   * Reset the counts. This should be called when breaking a session in Telemetry.
+   */
+  reset() {
+    this._domainSet.clear();
+  },
+
+  /**
+   * Returns the number of unique domains visited in this session during the
+   * last 24 hours.
+   */
+  get uniqueDomainsVisitedInPast24Hours() {
+    return this._domain24hrSet.size;
+  },
+
+  /**
+   * Resets the number of unique domains visited in this session.
+   */
+  resetUniqueDomainsVisitedInPast24Hours() {
+    this._timeouts.forEach(timeoutId => lazy.clearTimeout(timeoutId));
+    this._timeouts.clear();
+    this._domain24hrSet.clear();
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+export let BrowserUsageTelemetry = {
+  /**
+   * This is a policy object used to override behavior for testing.
+   */
+  Policy: {
+    getTelemetryClientId: async () => lazy.ClientID.getClientID(),
+    getUpdateDirectory: () => Services.dirsvc.get("UpdRootD", Ci.nsIFile),
+    readProfileCountFile: async path => IOUtils.readUTF8(path),
+    writeProfileCountFile: async (path, data) => IOUtils.writeUTF8(path, data),
+  },
+
+  _inited: false,
+
+  init() {
+    this._lastRecordTabCount = 0;
+    this._lastRecordLoadedTabCount = 0;
+    this._setupAfterRestore();
+    this._inited = true;
+
+    Services.prefs.addObserver("browser.tabs.inTitlebar", this);
+
+    this._recordUITelemetry();
+
+    this._onTabsOpenedTask = new lazy.DeferredTask(
+      () => this._onTabsOpened(),
+      0
+    );
+  },
+
+  /**
+   * Resets the masked add-on identifiers. Only for use in tests.
+   */
+  _resetAddonIds() {
+    KNOWN_ADDONS.length = 0;
+  },
+
+  /**
+   * Handle subsession splits in the parent process.
+   */
+  afterSubsessionSplit() {
+    // Scalars just got cleared due to a subsession split. We need to set the maximum
+    // concurrent tab and window counts so that they reflect the correct value for the
+    // new subsession.
+    const counts = getOpenTabsAndWinsCounts();
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_COUNT_SCALAR_NAME,
+      counts.tabCount
+    );
+    Services.telemetry.scalarSetMaximum(
+      MAX_WINDOW_COUNT_SCALAR_NAME,
+      counts.winCount
+    );
+
+    // Reset the URI counter.
+    URICountListener.reset();
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIObserver",
+    "nsISupportsWeakReference",
+  ]),
+
+  uninit() {
+    if (!this._inited) {
+      return;
+    }
+    Services.obs.removeObserver(this, DOMWINDOW_OPENED_TOPIC);
+    Services.obs.removeObserver(this, TELEMETRY_SUBSESSIONSPLIT_TOPIC);
+  },
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case DOMWINDOW_OPENED_TOPIC:
+        this._onWindowOpen(subject);
+        break;
+      case TELEMETRY_SUBSESSIONSPLIT_TOPIC:
+        this.afterSubsessionSplit();
+        break;
+      case "nsPref:changed":
+        switch (data) {
+          case "browser.tabs.inTitlebar":
+            this._recordWidgetChange(
+              "titlebar",
+              Services.appinfo.drawInTitlebar ? "off" : "on",
+              "pref"
+            );
+            break;
+        }
+        break;
+    }
+  },
+
+  handleEvent(event) {
+    switch (event.type) {
+      case "TabOpen":
+        this._onTabOpen();
+        break;
+      case "TabPinned":
+        this._onTabPinned();
+        break;
+      case "unload":
+        this._unregisterWindow(event.target);
+        break;
+      case TAB_RESTORING_TOPIC:
+        // We're restoring a new tab from a previous or crashed session.
+        // We don't want to track the URIs from these tabs, so let
+        // |URICountListener| know about them.
+        let browser = event.target.linkedBrowser;
+        URICountListener.addRestoredURI(browser, browser.currentURI);
+
+        const { loadedTabCount } = getOpenTabsAndWinsCounts();
+        this._recordTabCounts({ loadedTabCount });
+        break;
+    }
+  },
+
+  /**
+   * This gets called shortly after the SessionStore has finished restoring
+   * windows and tabs. It counts the open tabs and adds listeners to all the
+   * windows.
+   */
+  _setupAfterRestore() {
+    // Make sure to catch new chrome windows and subsession splits.
+    Services.obs.addObserver(this, DOMWINDOW_OPENED_TOPIC, true);
+    Services.obs.addObserver(this, TELEMETRY_SUBSESSIONSPLIT_TOPIC, true);
+
+    // Attach the tabopen handlers to the existing Windows.
+    for (let win of Services.wm.getEnumerator("navigator:browser")) {
+      this._registerWindow(win);
+    }
+
+    // Get the initial tab and windows max counts.
+    const counts = getOpenTabsAndWinsCounts();
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_COUNT_SCALAR_NAME,
+      counts.tabCount
+    );
+    Services.telemetry.scalarSetMaximum(
+      MAX_WINDOW_COUNT_SCALAR_NAME,
+      counts.winCount
+    );
+  },
+
+  _buildWidgetPositions() {
+    let widgetMap = new Map();
+
+    const toolbarState = nodeId => {
+      let value;
+      if (nodeId == "PersonalToolbar") {
+        value = Services.prefs.getCharPref(
+          "browser.toolbars.bookmarks.visibility",
+          "newtab"
+        );
+        if (value != "newtab") {
+          return value == "never" ? "off" : "on";
+        }
+        return value;
+      }
+      value = Services.xulStore.getValue(
+        AppConstants.BROWSER_CHROME_URL,
+        nodeId,
+        "collapsed"
+      );
+
+      if (value) {
+        return value == "true" ? "off" : "on";
+      }
+      return "off";
+    };
+
+    widgetMap.set(
+      BROWSER_UI_CONTAINER_IDS.PersonalToolbar,
+      toolbarState("PersonalToolbar")
+    );
+
+    let menuBarHidden =
+      Services.xulStore.getValue(
+        AppConstants.BROWSER_CHROME_URL,
+        "toolbar-menubar",
+        "autohide"
+      ) != "false";
+
+    widgetMap.set("menu-toolbar", menuBarHidden ? "off" : "on");
+
+    // Drawing in the titlebar means not showing the titlebar, hence the negation.
+    widgetMap.set("titlebar", Services.appinfo.drawInTitlebar ? "off" : "on");
+
+    for (let area of lazy.CustomizableUI.areas) {
+      if (!(area in BROWSER_UI_CONTAINER_IDS)) {
+        continue;
+      }
+
+      let position = BROWSER_UI_CONTAINER_IDS[area];
+      if (area == "nav-bar") {
+        position = `${BROWSER_UI_CONTAINER_IDS[area]}-start`;
+      }
+
+      let widgets = lazy.CustomizableUI.getWidgetsInArea(area);
+
+      for (let widget of widgets) {
+        if (!widget) {
+          continue;
+        }
+
+        if (widget.id.startsWith("customizableui-special-")) {
+          continue;
+        }
+
+        if (area == "nav-bar" && widget.id == "urlbar-container") {
+          position = `${BROWSER_UI_CONTAINER_IDS[area]}-end`;
+          continue;
+        }
+
+        widgetMap.set(widget.id, position);
+      }
+    }
+
+    let actions = lazy.PageActions.actions;
+    for (let action of actions) {
+      if (action.pinnedToUrlbar) {
+        widgetMap.set(action.id, "pageaction-urlbar");
+      }
+    }
+
+    return widgetMap;
+  },
+
+  _getWidgetID(node) {
+    // We want to find a sensible ID for this element.
+    if (!node) {
+      return null;
+    }
+
+    // See if this is a customizable widget.
+    if (node.ownerDocument.URL == AppConstants.BROWSER_CHROME_URL) {
+      // First find if it is inside one of the customizable areas.
+      for (let area of lazy.CustomizableUI.areas) {
+        if (node.closest(`#${CSS.escape(area)}`)) {
+          for (let widget of lazy.CustomizableUI.getWidgetIdsInArea(area)) {
+            if (
+              // We care about the buttons on the tabs themselves.
+              widget == "tabbrowser-tabs" ||
+              // We care about the page action and other buttons in here.
+              widget == "urlbar-container" ||
+              // We care about the actual menu items.
+              widget == "menubar-items" ||
+              // We care about individual bookmarks here.
+              widget == "personal-bookmarks"
+            ) {
+              continue;
+            }
+
+            if (node.closest(`#${CSS.escape(widget)}`)) {
+              return widget;
+            }
+          }
+          break;
+        }
+      }
+    }
+
+    if (node.id) {
+      return node.id;
+    }
+
+    // A couple of special cases in the tabs.
+    for (let cls of ["bookmark-item", "tab-icon-sound", "tab-close-button"]) {
+      if (!node.classList.contains(cls)) {
+        continue;
+      }
+      if (cls == "bookmark-item" && node.parentElement.id.includes("history")) {
+        return "history-item";
+      }
+      return cls;
+    }
+
+    // One of these will at least let us know what the widget is for.
+    let possibleAttributes = [
+      "preference",
+      "command",
+      "observes",
+      "data-l10n-id",
+    ];
+
+    // The key attribute on key elements is the actual key to listen for.
+    if (node.localName != "key") {
+      possibleAttributes.unshift("key");
+    }
+
+    for (let idAttribute of possibleAttributes) {
+      if (node.hasAttribute(idAttribute)) {
+        return node.getAttribute(idAttribute);
+      }
+    }
+
+    return this._getWidgetID(node.parentElement);
+  },
+
+  _getBrowserWidgetContainer(node) {
+    // Find the container holding this element.
+    for (let containerId of Object.keys(BROWSER_UI_CONTAINER_IDS)) {
+      let container = node.ownerDocument.getElementById(containerId);
+      if (container && container.contains(node)) {
+        return BROWSER_UI_CONTAINER_IDS[containerId];
+      }
+    }
+    // Treat toolbar context menu items that relate to tabs as the tab menu:
+    if (
+      node.closest("#toolbar-context-menu") &&
+      node.getAttribute("contexttype") == "tabbar"
+    ) {
+      return BROWSER_UI_CONTAINER_IDS.tabContextMenu;
+    }
+    return null;
+  },
+
+  _getWidgetContainer(node) {
+    if (node.localName == "key") {
+      return "keyboard";
+    }
+
+    const { URL } = node.ownerDocument;
+    if (URL == AppConstants.BROWSER_CHROME_URL) {
+      return this._getBrowserWidgetContainer(node);
+    }
+    if (URL.startsWith("about:preferences")) {
+      // Find the element's category.
+      let container = node.closest("[data-category]");
+      if (!container) {
+        return null;
+      }
+
+      let pane = container.getAttribute("data-category");
+
+      if (!PREFERENCES_PANES.includes(pane)) {
+        pane = "paneUnknown";
+      }
+
+      return `preferences_${pane}`;
+    }
+
+    return null;
+  },
+
+  lastClickTarget: null,
+
+  ignoreEvent(event) {
+    IGNORABLE_EVENTS.set(event, true);
+  },
+
+  _recordCommand(event) {
+    if (IGNORABLE_EVENTS.get(event)) {
+      return;
+    }
+
+    let sourceEvent = event;
+    while (sourceEvent.sourceEvent) {
+      sourceEvent = sourceEvent.sourceEvent;
+    }
+
+    let lastTarget = this.lastClickTarget?.get();
+    if (
+      lastTarget &&
+      sourceEvent.type == "command" &&
+      sourceEvent.target.contains(lastTarget)
+    ) {
+      // Ignore a command event triggered by a click.
+      this.lastClickTarget = null;
+      return;
+    }
+
+    this.lastClickTarget = null;
+
+    if (sourceEvent.type == "click") {
+      // Only care about main button clicks.
+      if (sourceEvent.button != 0) {
+        return;
+      }
+
+      // This click may trigger a command event so retain the target to be able
+      // to dedupe that event.
+      this.lastClickTarget = Cu.getWeakReference(sourceEvent.target);
+    }
+
+    // We should never see events from web content as they are fired in a
+    // content process, but let's be safe.
+    let url = sourceEvent.target.ownerDocument.documentURIObject;
+    if (!url.schemeIs("chrome") && !url.schemeIs("about")) {
+      return;
+    }
+
+    // This is what events targetted  at content will actually look like.
+    if (sourceEvent.target.localName == "browser") {
+      return;
+    }
+
+    // Find the actual element we're interested in.
+    let node = sourceEvent.target;
+    const isAboutPreferences =
+      node.ownerDocument.URL.startsWith("about:preferences");
+    while (
+      !UI_TARGET_ELEMENTS.includes(node.localName) &&
+      !node.classList?.contains("wants-telemetry") &&
+      // We are interested in links on about:preferences as well.
+      !(
+        isAboutPreferences &&
+        (node.getAttribute("is") === "text-link" || node.localName === "a")
+      )
+    ) {
+      node = node.parentNode;
+      if (!node?.parentNode) {
+        // A click on a space or label or top-level document or something we're
+        // not interested in.
+        return;
+      }
+    }
+
+    if (sourceEvent.type === "command") {
+      const { command, ownerDocument, parentNode } = node;
+      // Check if this command is for a history or bookmark link being opened
+      // from the context menu. In this case, we are interested in the DOM node
+      // for the link, not the menu item itself.
+      if (
+        PLACES_OPEN_COMMANDS.includes(command) ||
+        parentNode?.parentNode?.id === PLACES_OPEN_IN_CONTAINER_TAB_MENU_ID
+      ) {
+        node = ownerDocument.getElementById(PLACES_CONTEXT_MENU_ID).triggerNode;
+      }
+    }
+
+    let item = this._getWidgetID(node);
+    let source = this._getWidgetContainer(node);
+
+    if (item && source) {
+      let scalar = `browser.ui.interaction.${source.replace(/-/g, "_")}`;
+      Services.telemetry.keyedScalarAdd(scalar, telemetryId(item), 1);
+      if (SET_USAGECOUNT_PREF_BUTTONS.includes(item)) {
+        let pref = `browser.engagement.${item}.used-count`;
+        Services.prefs.setIntPref(pref, Services.prefs.getIntPref(pref, 0) + 1);
+      }
+      if (SET_USAGE_PREF_BUTTONS.includes(item)) {
+        Services.prefs.setBoolPref(`browser.engagement.${item}.has-used`, true);
+      }
+    }
+
+    if (ENTRYPOINT_TRACKED_CONTEXT_MENU_IDS[source]) {
+      let contextMenu = ENTRYPOINT_TRACKED_CONTEXT_MENU_IDS[source];
+      let triggerContainer = this._getWidgetContainer(
+        node.closest("menupopup")?.triggerNode
+      );
+      if (triggerContainer) {
+        let scalar = `browser.ui.interaction.${contextMenu.replace(/-/g, "_")}`;
+        Services.telemetry.keyedScalarAdd(
+          scalar,
+          telemetryId(triggerContainer),
+          1
+        );
+      }
+    }
+  },
+
+  /**
+   * Listens for UI interactions in the window.
+   */
+  _addUsageListeners(win) {
+    // Listen for command events from the UI.
+    win.addEventListener("command", event => this._recordCommand(event), true);
+    win.addEventListener("click", event => this._recordCommand(event), true);
+  },
+
+  /**
+   * A public version of the private method to take care of the `nav-bar-start`,
+   * `nav-bar-end` thing that callers shouldn't have to care about. It also
+   * accepts the DOM ids for the areas rather than the cleaner ones we report
+   * to telemetry.
+   */
+  recordWidgetChange(widgetId, newPos, reason) {
+    try {
+      if (newPos) {
+        newPos = BROWSER_UI_CONTAINER_IDS[newPos];
+      }
+
+      if (newPos == "nav-bar") {
+        let { position } = lazy.CustomizableUI.getPlacementOfWidget(widgetId);
+        let { position: urlPosition } =
+          lazy.CustomizableUI.getPlacementOfWidget("urlbar-container");
+        newPos = newPos + (urlPosition > position ? "-start" : "-end");
+      }
+
+      this._recordWidgetChange(widgetId, newPos, reason);
+    } catch (e) {
+      console.error(e);
+    }
+  },
+
+  recordToolbarVisibility(toolbarId, newState, reason) {
+    if (typeof newState != "string") {
+      newState = newState ? "on" : "off";
+    }
+    this._recordWidgetChange(
+      BROWSER_UI_CONTAINER_IDS[toolbarId],
+      newState,
+      reason
+    );
+  },
+
+  _recordWidgetChange(widgetId, newPos, reason) {
+    // In some cases (like when add-ons are detected during startup) this gets
+    // called before we've reported the initial positions. Ignore such cases.
+    if (!this.widgetMap) {
+      return;
+    }
+
+    if (widgetId == "urlbar-container") {
+      // We don't report the position of the url bar, it is after nav-bar-start
+      // and before nav-bar-end. But moving it means the widgets around it have
+      // effectively moved so update those.
+      let position = "nav-bar-start";
+      let widgets = lazy.CustomizableUI.getWidgetsInArea("nav-bar");
+
+      for (let widget of widgets) {
+        if (!widget) {
+          continue;
+        }
+
+        if (widget.id.startsWith("customizableui-special-")) {
+          continue;
+        }
+
+        if (widget.id == "urlbar-container") {
+          position = "nav-bar-end";
+          continue;
+        }
+
+        // This will do nothing if the position hasn't changed.
+        this._recordWidgetChange(widget.id, position, reason);
+      }
+
+      return;
+    }
+
+    let oldPos = this.widgetMap.get(widgetId);
+    if (oldPos == newPos) {
+      return;
+    }
+
+    let action = "move";
+
+    if (!oldPos) {
+      action = "add";
+    } else if (!newPos) {
+      action = "remove";
+    }
+
+    let key = `${telemetryId(widgetId, false)}_${action}_${oldPos ?? "na"}_${
+      newPos ?? "na"
+    }_${reason}`;
+    Services.telemetry.keyedScalarAdd("browser.ui.customized_widgets", key, 1);
+
+    if (newPos) {
+      this.widgetMap.set(widgetId, newPos);
+    } else {
+      this.widgetMap.delete(widgetId);
+    }
+  },
+
+  _recordUITelemetry() {
+    this.widgetMap = this._buildWidgetPositions();
+
+    for (let [widgetId, position] of this.widgetMap.entries()) {
+      let key = `${telemetryId(widgetId, false)}_pinned_${position}`;
+      Services.telemetry.keyedScalarSet(
+        "browser.ui.toolbar_widgets",
+        key,
+        true
+      );
+    }
+  },
+
+  /**
+   * Adds listeners to a single chrome window.
+   */
+  _registerWindow(win) {
+    this._addUsageListeners(win);
+
+    win.addEventListener("unload", this);
+    win.addEventListener("TabOpen", this, true);
+    win.addEventListener("TabPinned", this, true);
+
+    win.gBrowser.tabContainer.addEventListener(TAB_RESTORING_TOPIC, this);
+    win.gBrowser.addTabsProgressListener(URICountListener);
+  },
+
+  /**
+   * Removes listeners from a single chrome window.
+   */
+  _unregisterWindow(win) {
+    win.removeEventListener("unload", this);
+    win.removeEventListener("TabOpen", this, true);
+    win.removeEventListener("TabPinned", this, true);
+
+    win.defaultView.gBrowser.tabContainer.removeEventListener(
+      TAB_RESTORING_TOPIC,
+      this
+    );
+    win.defaultView.gBrowser.removeTabsProgressListener(URICountListener);
+  },
+
+  /**
+   * Updates the tab counts.
+   */
+  _onTabOpen() {
+    // Update the "tab opened" count and its maximum.
+    Services.telemetry.scalarAdd(TAB_OPEN_EVENT_COUNT_SCALAR_NAME, 1);
+
+    // In the case of opening multiple tabs at once, avoid enumerating all open
+    // tabs and windows each time a tab opens.
+    this._onTabsOpenedTask.disarm();
+    this._onTabsOpenedTask.arm();
+  },
+
+  /**
+   * Update tab counts after opening multiple tabs.
+   */
+  _onTabsOpened() {
+    const { tabCount, loadedTabCount } = getOpenTabsAndWinsCounts();
+    Services.telemetry.scalarSetMaximum(MAX_TAB_COUNT_SCALAR_NAME, tabCount);
+
+    this._recordTabCounts({ tabCount, loadedTabCount });
+  },
+
+  _onTabPinned(target) {
+    const pinnedTabs = getPinnedTabsCount();
+
+    // Update the "tab pinned" count and its maximum.
+    Services.telemetry.scalarAdd(TAB_PINNED_EVENT_COUNT_SCALAR_NAME, 1);
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_PINNED_COUNT_SCALAR_NAME,
+      pinnedTabs
+    );
+  },
+
+  /**
+   * Tracks the window count and registers the listeners for the tab count.
+   * @param{Object} win The window object.
+   */
+  _onWindowOpen(win) {
+    // Make sure to have a |nsIDOMWindow|.
+    if (!(win instanceof Ci.nsIDOMWindow)) {
+      return;
+    }
+
+    let onLoad = () => {
+      win.removeEventListener("load", onLoad);
+
+      // Ignore non browser windows.
+      if (
+        win.document.documentElement.getAttribute("windowtype") !=
+        "navigator:browser"
+      ) {
+        return;
+      }
+
+      this._registerWindow(win);
+      // Track the window open event and check the maximum.
+      const counts = getOpenTabsAndWinsCounts();
+      Services.telemetry.scalarAdd(WINDOW_OPEN_EVENT_COUNT_SCALAR_NAME, 1);
+      Services.telemetry.scalarSetMaximum(
+        MAX_WINDOW_COUNT_SCALAR_NAME,
+        counts.winCount
+      );
+
+      // We won't receive the "TabOpen" event for the first tab within a new window.
+      // Account for that.
+      this._onTabOpen(counts);
+    };
+    win.addEventListener("load", onLoad);
+  },
+
+  /**
+   * Record telemetry about the given tab counts.
+   *
+   * Telemetry for each count will only be recorded if the value isn't
+   * `undefined`.
+   *
+   * @param {object} [counts] The tab counts to register with telemetry.
+   * @param {number} [counts.tabCount] The number of tabs in all browsers.
+   * @param {number} [counts.loadedTabCount] The number of loaded (i.e., not
+   *                                         pending) tabs in all browsers.
+   */
+  _recordTabCounts({ tabCount, loadedTabCount }) {
+    let currentTime = Date.now();
+    if (
+      tabCount !== undefined &&
+      currentTime > this._lastRecordTabCount + MINIMUM_TAB_COUNT_INTERVAL_MS
+    ) {
+      Services.telemetry.getHistogramById("TAB_COUNT").add(tabCount);
+      this._lastRecordTabCount = currentTime;
+    }
+
+    if (
+      loadedTabCount !== undefined &&
+      currentTime >
+        this._lastRecordLoadedTabCount + MINIMUM_TAB_COUNT_INTERVAL_MS
+    ) {
+      Services.telemetry
+        .getHistogramById("LOADED_TAB_COUNT")
+        .add(loadedTabCount);
+      this._lastRecordLoadedTabCount = currentTime;
+    }
+  },
+
+  _checkProfileCountFileSchema(fileData) {
+    // Verifies that the schema of the file is the expected schema
+    if (typeof fileData.version != "string") {
+      throw new Error("Schema Mismatch Error: Bad type for 'version' field");
+    }
+    if (!Array.isArray(fileData.profileTelemetryIds)) {
+      throw new Error(
+        "Schema Mismatch Error: Bad type for 'profileTelemetryIds' field"
+      );
+    }
+    for (let profileTelemetryId of fileData.profileTelemetryIds) {
+      if (typeof profileTelemetryId != "string") {
+        throw new Error(
+          "Schema Mismatch Error: Bad type for an element of 'profileTelemetryIds'"
+        );
+      }
+    }
+  },
+
+  // Reports the number of Firefox profiles on this machine to telemetry.
+  async reportProfileCount() {
+    if (
+      AppConstants.platform != "win" ||
+      !AppConstants.MOZ_TELEMETRY_REPORTING
+    ) {
+      // This is currently a windows-only feature.
+      // Also, this function writes directly to disk, without using the usual
+      // telemetry recording functions. So we excplicitly check if telemetry
+      // reporting was disabled at compile time, and we do not do anything in
+      // case.
+      return;
+    }
+
+    // To report only as much data as we need, we will bucket our values.
+    // Rather than the raw value, we will report the greatest value in the list
+    // below that is no larger than the raw value.
+    const buckets = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 10000];
+
+    // We need both the C:\ProgramData\Mozilla directory and the install
+    // directory hash to create the profile count file path. We can easily
+    // reassemble this from the update directory, which looks like:
+    // C:\ProgramData\Mozilla\updates\hash
+    // Retrieving the directory this way also ensures that the "Mozilla"
+    // directory is created with the correct permissions.
+    // The ProgramData directory, by default, grants write permissions only to
+    // file creators. The directory service calls GetCommonUpdateDirectory,
+    // which makes sure the the directory is created with user-writable
+    // permissions.
+    const updateDirectory = BrowserUsageTelemetry.Policy.getUpdateDirectory();
+    const hash = updateDirectory.leafName;
+    const profileCountFilename = "profile_count_" + hash + ".json";
+    let profileCountFile = updateDirectory.parent.parent;
+    profileCountFile.append(profileCountFilename);
+
+    let readError = false;
+    let fileData;
+    try {
+      let json = await BrowserUsageTelemetry.Policy.readProfileCountFile(
+        profileCountFile.path
+      );
+      fileData = JSON.parse(json);
+      BrowserUsageTelemetry._checkProfileCountFileSchema(fileData);
+    } catch (ex) {
+      // Note that since this also catches the "no such file" error, this is
+      // always the template that we use when writing to the file for the first
+      // time.
+      fileData = { version: "1", profileTelemetryIds: [] };
+      if (!(ex.name == "NotFoundError")) {
+        console.error(ex);
+        // Don't just return here on a read error. We need to send the error
+        // value to telemetry and we want to attempt to fix the file.
+        // However, we will still report an error for this ping, even if we
+        // fix the file. This is to prevent always sending a profile count of 1
+        // if, for some reason, we always get a read error but never a write
+        // error.
+        readError = true;
+      }
+    }
+
+    let writeError = false;
+    let currentTelemetryId =
+      await BrowserUsageTelemetry.Policy.getTelemetryClientId();
+    // Don't add our telemetry ID to the file if we've already reached the
+    // largest bucket. This prevents the file size from growing forever.
+    if (
+      !fileData.profileTelemetryIds.includes(currentTelemetryId) &&
+      fileData.profileTelemetryIds.length < Math.max(...buckets)
+    ) {
+      fileData.profileTelemetryIds.push(currentTelemetryId);
+      try {
+        await BrowserUsageTelemetry.Policy.writeProfileCountFile(
+          profileCountFile.path,
+          JSON.stringify(fileData)
+        );
+      } catch (ex) {
+        console.error(ex);
+        writeError = true;
+      }
+    }
+
+    // Determine the bucketed value to report
+    let rawProfileCount = fileData.profileTelemetryIds.length;
+    let valueToReport = 0;
+    for (let bucket of buckets) {
+      if (bucket <= rawProfileCount && bucket > valueToReport) {
+        valueToReport = bucket;
+      }
+    }
+
+    if (readError || writeError) {
+      // We convey errors via a profile count of 0.
+      valueToReport = 0;
+    }
+
+    Services.telemetry.scalarSet(
+      "browser.engagement.profile_count",
+      valueToReport
+    );
+    // Manually mirror to Glean
+    Glean.browserEngagement.profileCount.set(valueToReport);
+  },
+
+  /**
+   * Check if this is the first run of this profile since installation,
+   * if so then send installation telemetry.
+   *
+   * @param {nsIFile} [dataPathOverride] Optional, full data file path, for tests.
+   * @param {Array<string>} [msixPackagePrefixes] Optional, list of prefixes to
+            consider "existing" installs when looking at installed MSIX packages.
+            Defaults to prefixes for builds produced in Firefox automation.
+   * @return {Promise}
+   * @resolves When the event has been recorded, or if the data file was not found.
+   * @rejects JavaScript exception on any failure.
+   */
+  async reportInstallationTelemetry(
+    dataPathOverride,
+    msixPackagePrefixes = ["Mozilla.Firefox", "Mozilla.MozillaFirefox"]
+  ) {
+    if (AppConstants.platform != "win") {
+      // This is a windows-only feature.
+      return;
+    }
+
+    const TIMESTAMP_PREF = "app.installation.timestamp";
+    const lastInstallTime = Services.prefs.getStringPref(TIMESTAMP_PREF, null);
+    const wpm = Cc["@mozilla.org/windows-package-manager;1"].createInstance(
+      Ci.nsIWindowsPackageManager
+    );
+    let installer_type = "";
+    let pfn;
+    try {
+      pfn = Services.sysinfo.getProperty("winPackageFamilyName");
+    } catch (e) {}
+
+    function getInstallData() {
+      // We only care about where _any_ other install existed - no
+      // need to count more than 1.
+      const installPaths = lazy.WindowsInstallsInfo.getInstallPaths(
+        1,
+        new Set([Services.dirsvc.get("GreBinD", Ci.nsIFile).path])
+      );
+      const msixInstalls = new Set();
+      // We're just going to eat all errors here -- we don't want the event
+      // to go unsent if we were unable to look for MSIX installs.
+      try {
+        wpm
+          .findUserInstalledPackages(msixPackagePrefixes)
+          .forEach(i => msixInstalls.add(i));
+        if (pfn) {
+          msixInstalls.delete(pfn);
+        }
+      } catch (ex) {}
+      return {
+        installPaths,
+        msixInstalls,
+      };
+    }
+
+    let extra = {};
+
+    if (pfn) {
+      if (lastInstallTime != null) {
+        // We've already seen this install
+        return;
+      }
+
+      // First time seeing this install, record the timestamp.
+      Services.prefs.setStringPref(TIMESTAMP_PREF, wpm.getInstalledDate());
+      let install_data = getInstallData();
+
+      installer_type = "msix";
+
+      // Build the extra event data
+      extra.version = AppConstants.MOZ_APP_VERSION;
+      extra.build_id = AppConstants.MOZ_BUILDID;
+      // The next few keys are static for the reasons described
+      // No way to detect whether or not we were installed by an admin
+      extra.admin_user = "false";
+      // Always false at the moment, because we create a new profile
+      // on first launch
+      extra.profdir_existed = "false";
+      // Obviously false for MSIX installs
+      extra.from_msi = "false";
+      // We have no way of knowing whether we were installed via the GUI,
+      // through the command line, or some Enterprise management tool.
+      extra.silent = "false";
+      // There's no way to change the install path for an MSIX package
+      extra.default_path = "true";
+      extra.install_existed = install_data.msixInstalls.has(pfn).toString();
+      install_data.msixInstalls.delete(pfn);
+      extra.other_inst = (!!install_data.installPaths.size).toString();
+      extra.other_msix_inst = (!!install_data.msixInstalls.size).toString();
+    } else {
+      let dataPath = dataPathOverride;
+      if (!dataPath) {
+        dataPath = Services.dirsvc.get("GreD", Ci.nsIFile);
+        dataPath.append("installation_telemetry.json");
+      }
+
+      let dataBytes;
+      try {
+        dataBytes = await IOUtils.read(dataPath.path);
+      } catch (ex) {
+        if (ex.name == "NotFoundError") {
+          // Many systems will not have the data file, return silently if not found as
+          // there is nothing to record.
+          return;
+        }
+        throw ex;
+      }
+      const dataString = new TextDecoder("utf-16").decode(dataBytes);
+      const data = JSON.parse(dataString);
+
+      if (lastInstallTime && data.install_timestamp == lastInstallTime) {
+        // We've already seen this install
+        return;
+      }
+
+      // First time seeing this install, record the timestamp.
+      Services.prefs.setStringPref(TIMESTAMP_PREF, data.install_timestamp);
+      let install_data = getInstallData();
+
+      installer_type = data.installer_type;
+
+      // Installation timestamp is not intended to be sent with telemetry,
+      // remove it to emphasize this point.
+      delete data.install_timestamp;
+
+      // Build the extra event data
+      extra.version = data.version;
+      extra.build_id = data.build_id;
+      extra.admin_user = data.admin_user.toString();
+      extra.install_existed = data.install_existed.toString();
+      extra.profdir_existed = data.profdir_existed.toString();
+      extra.other_inst = (!!install_data.installPaths.size).toString();
+      extra.other_msix_inst = (!!install_data.msixInstalls.size).toString();
+
+      if (data.installer_type == "full") {
+        extra.silent = data.silent.toString();
+        extra.from_msi = data.from_msi.toString();
+        extra.default_path = data.default_path.toString();
+      }
+    }
+    // Record the event
+    Services.telemetry.setEventRecordingEnabled("installation", true);
+    Services.telemetry.recordEvent(
+      "installation",
+      "first_seen",
+      installer_type,
+      null,
+      extra
+    );
+  },
+};
+
+// Used by nsIBrowserUsage
+export function getUniqueDomainsVisitedInPast24Hours() {
+  return URICountListener.uniqueDomainsVisitedInPast24Hours;
+}
diff --git a/browser/modules/BrowserWindowTracker.sys.mjs b/browser/modules/BrowserWindowTracker.sys.mjs
new file mode 100644
index 0000000000..a15c6a0fb7
--- /dev/null
+++ b/browser/modules/BrowserWindowTracker.sys.mjs
@@ -0,0 +1,442 @@
+/* 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/. */
+
+/*
+ * This module tracks each browser window and informs network module
+ * the current selected tab's content outer window ID.
+ */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+// Lazy getters
+
+XPCOMUtils.defineLazyServiceGetters(lazy, {
+  BrowserHandler: ["@mozilla.org/browser/clh;1", "nsIBrowserHandler"],
+});
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  HomePage: "resource:///modules/HomePage.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+// Constants
+const TAB_EVENTS = ["TabBrowserInserted", "TabSelect"];
+const WINDOW_EVENTS = ["activate", "unload"];
+const DEBUG = false;
+
+// Variables
+let _lastCurrentBrowserId = 0;
+let _trackedWindows = [];
+
+// Global methods
+function debug(s) {
+  if (DEBUG) {
+    dump("-*- UpdateBrowserIDHelper: " + s + "\n");
+  }
+}
+
+function _updateCurrentBrowserId(browser) {
+  if (
+    !browser.browserId ||
+    browser.browserId === _lastCurrentBrowserId ||
+    browser.ownerGlobal != _trackedWindows[0]
+  ) {
+    return;
+  }
+
+  // Guard on DEBUG here because materializing a long data URI into
+  // a JS string for concatenation is not free.
+  if (DEBUG) {
+    debug(
+      `Current window uri=${browser.currentURI?.spec} browser id=${browser.browserId}`
+    );
+  }
+
+  _lastCurrentBrowserId = browser.browserId;
+  let idWrapper = Cc["@mozilla.org/supports-PRUint64;1"].createInstance(
+    Ci.nsISupportsPRUint64
+  );
+  idWrapper.data = _lastCurrentBrowserId;
+  Services.obs.notifyObservers(idWrapper, "net:current-browser-id");
+}
+
+function _handleEvent(event) {
+  switch (event.type) {
+    case "TabBrowserInserted":
+      if (
+        event.target.ownerGlobal.gBrowser.selectedBrowser ===
+        event.target.linkedBrowser
+      ) {
+        _updateCurrentBrowserId(event.target.linkedBrowser);
+      }
+      break;
+    case "TabSelect":
+      _updateCurrentBrowserId(event.target.linkedBrowser);
+      break;
+    case "activate":
+      WindowHelper.onActivate(event.target);
+      break;
+    case "unload":
+      WindowHelper.removeWindow(event.currentTarget);
+      break;
+  }
+}
+
+function _trackWindowOrder(window) {
+  if (window.windowState == window.STATE_MINIMIZED) {
+    let firstMinimizedWindow = _trackedWindows.findIndex(
+      w => w.windowState == w.STATE_MINIMIZED
+    );
+    if (firstMinimizedWindow == -1) {
+      firstMinimizedWindow = _trackedWindows.length;
+    }
+    _trackedWindows.splice(firstMinimizedWindow, 0, window);
+  } else {
+    _trackedWindows.unshift(window);
+  }
+}
+
+function _untrackWindowOrder(window) {
+  let idx = _trackedWindows.indexOf(window);
+  if (idx >= 0) {
+    _trackedWindows.splice(idx, 1);
+  }
+}
+
+function topicObserved(observeTopic, checkFn) {
+  return new Promise((resolve, reject) => {
+    function observer(subject, topic, data) {
+      try {
+        if (checkFn && !checkFn(subject, data)) {
+          return;
+        }
+        Services.obs.removeObserver(observer, topic);
+        checkFn = null;
+        resolve([subject, data]);
+      } catch (ex) {
+        Services.obs.removeObserver(observer, topic);
+        checkFn = null;
+        reject(ex);
+      }
+    }
+    Services.obs.addObserver(observer, observeTopic);
+  });
+}
+
+// Methods that impact a window. Put into single object for organization.
+var WindowHelper = {
+  addWindow(window) {
+    // Add event listeners
+    TAB_EVENTS.forEach(function (event) {
+      window.gBrowser.tabContainer.addEventListener(event, _handleEvent);
+    });
+    WINDOW_EVENTS.forEach(function (event) {
+      window.addEventListener(event, _handleEvent);
+    });
+
+    _trackWindowOrder(window);
+
+    // Update the selected tab's content outer window ID.
+    _updateCurrentBrowserId(window.gBrowser.selectedBrowser);
+  },
+
+  removeWindow(window) {
+    _untrackWindowOrder(window);
+
+    // Remove the event listeners
+    TAB_EVENTS.forEach(function (event) {
+      window.gBrowser.tabContainer.removeEventListener(event, _handleEvent);
+    });
+    WINDOW_EVENTS.forEach(function (event) {
+      window.removeEventListener(event, _handleEvent);
+    });
+  },
+
+  onActivate(window) {
+    // If this window was the last focused window, we don't need to do anything
+    if (window == _trackedWindows[0]) {
+      return;
+    }
+
+    _untrackWindowOrder(window);
+    _trackWindowOrder(window);
+
+    _updateCurrentBrowserId(window.gBrowser.selectedBrowser);
+  },
+};
+
+export const BrowserWindowTracker = {
+  pendingWindows: new Map(),
+
+  /**
+   * Get the most recent browser window.
+   *
+   * @param options an object accepting the arguments for the search.
+   *        * private: true to restrict the search to private windows
+   *            only, false to restrict the search to non-private only.
+   *            Omit the property to search in both groups.
+   *        * allowPopups: true if popup windows are permissable.
+   */
+  getTopWindow(options = {}) {
+    for (let win of _trackedWindows) {
+      if (
+        !win.closed &&
+        (options.allowPopups || win.toolbar.visible) &&
+        (!("private" in options) ||
+          lazy.PrivateBrowsingUtils.permanentPrivateBrowsing ||
+          lazy.PrivateBrowsingUtils.isWindowPrivate(win) == options.private)
+      ) {
+        return win;
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Get a window that is in the process of loading. Only supports windows
+   * opened via the `openWindow` function in this module or that have been
+   * registered with the `registerOpeningWindow` function.
+   *
+   * @param {Object} options
+   *   Options for the search.
+   * @param {boolean} [options.private]
+   *   true to restrict the search to private windows only, false to restrict
+   *   the search to non-private only. Omit the property to search in both
+   *   groups.
+   *
+   * @returns {Promise<Window> | null}
+   */
+  getPendingWindow(options = {}) {
+    for (let pending of this.pendingWindows.values()) {
+      if (
+        !("private" in options) ||
+        lazy.PrivateBrowsingUtils.permanentPrivateBrowsing ||
+        pending.isPrivate == options.private
+      ) {
+        return pending.deferred.promise;
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Registers a browser window that is in the process of opening. Normally it
+   * would be preferable to use the standard method for opening the window from
+   * this module.
+   *
+   * @param {Window} window
+   *   The opening window.
+   * @param {boolean} isPrivate
+   *   Whether the opening window is a private browsing window.
+   */
+  registerOpeningWindow(window, isPrivate) {
+    let deferred = Promise.withResolvers();
+
+    this.pendingWindows.set(window, {
+      isPrivate,
+      deferred,
+    });
+
+    // Prevent leaks in case the window closes before we track it as an open
+    // window.
+    const topic = "browsing-context-discarded";
+    const observer = (aSubject, aTopic, aData) => {
+      if (window.browsingContext == aSubject) {
+        let pending = this.pendingWindows.get(window);
+        if (pending) {
+          this.pendingWindows.delete(window);
+          pending.deferred.resolve(window);
+        }
+        Services.obs.removeObserver(observer, topic);
+      }
+    };
+    Services.obs.addObserver(observer, topic);
+  },
+
+  /**
+   * A standard function for opening a new browser window.
+   *
+   * @param {Object} [options]
+   *   Options for the new window.
+   * @param {Window} [options.openerWindow]
+   *   An existing browser window to open the new one from.
+   * @param {boolean} [options.private]
+   *   True to make the window a private browsing window.
+   * @param {String} [options.features]
+   *   Additional window features to give the new window.
+   * @param {nsIArray | nsISupportsString} [options.args]
+   *   Arguments to pass to the new window.
+   * @param {boolean} [options.remote]
+   *   A boolean indicating if the window should run remote browser tabs or
+   *   not. If omitted, the window  will choose the profile default state.
+   * @param {boolean} [options.fission]
+   *   A boolean indicating if the window should run with fission enabled or
+   *   not. If omitted, the window will choose the profile default state.
+   *
+   * @returns {Window}
+   */
+  openWindow({
+    openerWindow = undefined,
+    private: isPrivate = false,
+    features = undefined,
+    args = null,
+    remote = undefined,
+    fission = undefined,
+  } = {}) {
+    let telemetryObj = {};
+    TelemetryStopwatch.start("FX_NEW_WINDOW_MS", telemetryObj);
+
+    let windowFeatures = "chrome,dialog=no,all";
+    if (features) {
+      windowFeatures += `,${features}`;
+    }
+    let loadURIString;
+    if (isPrivate && lazy.PrivateBrowsingUtils.enabled) {
+      windowFeatures += ",private";
+      if (!args && !lazy.PrivateBrowsingUtils.permanentPrivateBrowsing) {
+        // Force the new window to load about:privatebrowsing instead of the
+        // default home page.
+        loadURIString = "about:privatebrowsing";
+      }
+    } else {
+      windowFeatures += ",non-private";
+    }
+    if (!args) {
+      loadURIString ??= lazy.BrowserHandler.defaultArgs;
+      args = Cc["@mozilla.org/supports-string;1"].createInstance(
+        Ci.nsISupportsString
+      );
+      args.data = loadURIString;
+    }
+
+    if (remote) {
+      windowFeatures += ",remote";
+    } else if (remote === false) {
+      windowFeatures += ",non-remote";
+    }
+
+    if (fission) {
+      windowFeatures += ",fission";
+    } else if (fission === false) {
+      windowFeatures += ",non-fission";
+    }
+
+    // If the opener window is maximized, we want to skip the animation, since
+    // we're going to be taking up most of the screen anyways, and we want to
+    // optimize for showing the user a useful window as soon as possible.
+    if (openerWindow?.windowState == openerWindow?.STATE_MAXIMIZED) {
+      windowFeatures += ",suppressanimation";
+    }
+
+    let win = Services.ww.openWindow(
+      openerWindow,
+      AppConstants.BROWSER_CHROME_URL,
+      "_blank",
+      windowFeatures,
+      args
+    );
+    this.registerOpeningWindow(win, isPrivate);
+
+    win.addEventListener(
+      "MozAfterPaint",
+      () => {
+        TelemetryStopwatch.finish("FX_NEW_WINDOW_MS", telemetryObj);
+        if (
+          Services.prefs.getIntPref("browser.startup.page") == 1 &&
+          loadURIString == lazy.HomePage.get()
+        ) {
+          // A notification for when a user has triggered their homepage. This
+          // is used to display a doorhanger explaining that an extension has
+          // modified the homepage, if necessary.
+          Services.obs.notifyObservers(win, "browser-open-homepage-start");
+        }
+      },
+      { once: true }
+    );
+
+    return win;
+  },
+
+  /**
+   * Async version of `openWindow` waiting for delayed startup of the new
+   * window before returning.
+   *
+   * @param {Object} [options]
+   *   Options for the new window. See `openWindow` for details.
+   *
+   * @returns {Window}
+   */
+  async promiseOpenWindow(options) {
+    let win = this.openWindow(options);
+    await topicObserved(
+      "browser-delayed-startup-finished",
+      subject => subject == win
+    );
+    return win;
+  },
+
+  /**
+   * Number of currently open browser windows.
+   */
+  get windowCount() {
+    return _trackedWindows.length;
+  },
+
+  /**
+   * Array of browser windows ordered by z-index, in reverse order.
+   * This means that the top-most browser window will be the first item.
+   */
+  get orderedWindows() {
+    // Clone the windows array immediately as it may change during iteration,
+    // we'd rather have an outdated order than skip/revisit windows.
+    return [..._trackedWindows];
+  },
+
+  getAllVisibleTabs() {
+    let tabs = [];
+    for (let win of BrowserWindowTracker.orderedWindows) {
+      for (let tab of win.gBrowser.visibleTabs) {
+        // Only use tabs which are not discarded / unrestored
+        if (tab.linkedPanel) {
+          let { contentTitle, browserId } = tab.linkedBrowser;
+          tabs.push({ contentTitle, browserId });
+        }
+      }
+    }
+    return tabs;
+  },
+
+  track(window) {
+    let pending = this.pendingWindows.get(window);
+    if (pending) {
+      this.pendingWindows.delete(window);
+      // Waiting for delayed startup to complete ensures that this new window
+      // has started loading its initial urls.
+      window.delayedStartupPromise.then(() => pending.deferred.resolve(window));
+    }
+
+    return WindowHelper.addWindow(window);
+  },
+
+  getBrowserById(browserId) {
+    for (let win of BrowserWindowTracker.orderedWindows) {
+      for (let tab of win.gBrowser.visibleTabs) {
+        if (tab.linkedPanel && tab.linkedBrowser.browserId === browserId) {
+          return tab.linkedBrowser;
+        }
+      }
+    }
+    return null;
+  },
+
+  // For tests only, this function will remove this window from the list of
+  // tracked windows. Please don't forget to add it back at the end of your
+  // tests!
+  untrackForTestsOnly(window) {
+    return WindowHelper.removeWindow(window);
+  },
+};
diff --git a/browser/modules/ContentCrashHandlers.sys.mjs b/browser/modules/ContentCrashHandlers.sys.mjs
new file mode 100644
index 0000000000..4ab6f600cd
--- /dev/null
+++ b/browser/modules/ContentCrashHandlers.sys.mjs
@@ -0,0 +1,1132 @@
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
+  CrashSubmit: "resource://gre/modules/CrashSubmit.sys.mjs",
+  E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs",
+  SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs",
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+// We don't process crash reports older than 28 days, so don't bother
+// submitting them
+const PENDING_CRASH_REPORT_DAYS = 28;
+const DAY = 24 * 60 * 60 * 1000; // milliseconds
+const DAYS_TO_SUPPRESS = 30;
+const MAX_UNSEEN_CRASHED_CHILD_IDS = 20;
+const MAX_UNSEEN_CRASHED_SUBFRAME_IDS = 10;
+
+// Time after which we will begin scanning for unsubmitted crash reports
+const CHECK_FOR_UNSUBMITTED_CRASH_REPORTS_DELAY_MS = 60 * 10000; // 10 minutes
+
+// This is SIGUSR1 and indicates a user-invoked crash
+const EXIT_CODE_CONTENT_CRASHED = 245;
+
+const TABCRASHED_ICON_URI = "chrome://browser/skin/tab-crashed.svg";
+
+const SUBFRAMECRASH_LEARNMORE_URI =
+  "https://support.mozilla.org/kb/firefox-crashes-troubleshoot-prevent-and-get-help";
+
+/**
+ * BrowserWeakMap is exactly like a WeakMap, but expects <xul:browser>
+ * objects only.
+ *
+ * Under the hood, BrowserWeakMap keys the map off of the <xul:browser>
+ * permanentKey. If, however, the browser has never gotten a permanentKey,
+ * it falls back to keying on the <xul:browser> element itself.
+ */
+class BrowserWeakMap extends WeakMap {
+  get(browser) {
+    if (browser.permanentKey) {
+      return super.get(browser.permanentKey);
+    }
+    return super.get(browser);
+  }
+
+  set(browser, value) {
+    if (browser.permanentKey) {
+      return super.set(browser.permanentKey, value);
+    }
+    return super.set(browser, value);
+  }
+
+  delete(browser) {
+    if (browser.permanentKey) {
+      return super.delete(browser.permanentKey);
+    }
+    return super.delete(browser);
+  }
+}
+
+export var TabCrashHandler = {
+  _crashedTabCount: 0,
+  childMap: new Map(),
+  browserMap: new BrowserWeakMap(),
+  notificationsMap: new Map(),
+  unseenCrashedChildIDs: [],
+  pendingSubFrameCrashes: new Map(),
+  pendingSubFrameCrashesIDs: [],
+  crashedBrowserQueues: new Map(),
+  restartRequiredBrowsers: new WeakSet(),
+  testBuildIDMismatch: false,
+
+  get prefs() {
+    delete this.prefs;
+    return (this.prefs = Services.prefs.getBranch(
+      "browser.tabs.crashReporting."
+    ));
+  },
+
+  init() {
+    if (this.initialized) {
+      return;
+    }
+    this.initialized = true;
+
+    Services.obs.addObserver(this, "ipc:content-shutdown");
+    Services.obs.addObserver(this, "oop-frameloader-crashed");
+  },
+
+  observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "ipc:content-shutdown": {
+        aSubject.QueryInterface(Ci.nsIPropertyBag2);
+
+        if (!aSubject.get("abnormal")) {
+          return;
+        }
+
+        let childID = aSubject.get("childID");
+        let dumpID = aSubject.get("dumpID");
+
+        // Get and remove the subframe crash info first.
+        let subframeCrashItem = this.getAndRemoveSubframeCrash(childID);
+
+        if (!dumpID) {
+          Services.telemetry
+            .getHistogramById("FX_CONTENT_CRASH_DUMP_UNAVAILABLE")
+            .add(1);
+        } else if (AppConstants.MOZ_CRASHREPORTER) {
+          this.childMap.set(childID, dumpID);
+
+          // If this is a subframe crash, show the crash notification. Only
+          // show subframe notifications when there is a minidump available.
+          if (subframeCrashItem) {
+            let browsers =
+              ChromeUtils.nondeterministicGetWeakMapKeys(subframeCrashItem) ||
+              [];
+            for (let browserItem of browsers) {
+              let browser = subframeCrashItem.get(browserItem);
+              if (browser.isConnected && !browser.ownerGlobal.closed) {
+                this.showSubFrameNotification(browser, childID, dumpID);
+              }
+            }
+          }
+        }
+
+        if (!this.flushCrashedBrowserQueue(childID)) {
+          this.unseenCrashedChildIDs.push(childID);
+          // The elements in unseenCrashedChildIDs will only be removed if
+          // the tab crash page is shown. However, ipc:content-shutdown might
+          // be fired for processes for which we'll never show the tab crash
+          // page - for example, the thumbnailing process. Another case to
+          // consider is if the user is configured to submit backlogged crash
+          // reports automatically, and a background tab crashes. In that case,
+          // we will never show the tab crash page, and never remove the element
+          // from the list.
+          //
+          // Instead of trying to account for all of those cases, we prevent
+          // this list from getting too large by putting a reasonable upper
+          // limit on how many childIDs we track. It's unlikely that this
+          // array would ever get so large as to be unwieldy (that'd be a lot
+          // or crashes!), but a leak is a leak.
+          if (
+            this.unseenCrashedChildIDs.length > MAX_UNSEEN_CRASHED_CHILD_IDS
+          ) {
+            this.unseenCrashedChildIDs.shift();
+          }
+        }
+
+        // check for environment affecting crash reporting
+        let shutdown = Services.env.exists("MOZ_CRASHREPORTER_SHUTDOWN");
+
+        if (shutdown) {
+          dump(
+            "A content process crashed and MOZ_CRASHREPORTER_SHUTDOWN is " +
+              "set, shutting down\n"
+          );
+          Services.startup.quit(
+            Ci.nsIAppStartup.eForceQuit,
+            EXIT_CODE_CONTENT_CRASHED
+          );
+        }
+
+        break;
+      }
+      case "oop-frameloader-crashed": {
+        let browser = aSubject.ownerElement;
+        if (!browser) {
+          return;
+        }
+
+        this.browserMap.set(browser, aSubject.childID);
+        break;
+      }
+    }
+  },
+
+  /**
+   * This should be called once a content process has finished
+   * shutting down abnormally. Any tabbrowser browsers that were
+   * selected at the time of the crash will then be sent to
+   * the crashed tab page.
+   *
+   * @param childID (int)
+   *        The childID of the content process that just crashed.
+   * @returns boolean
+   *        True if one or more browsers were sent to the tab crashed
+   *        page.
+   */
+  flushCrashedBrowserQueue(childID) {
+    let browserQueue = this.crashedBrowserQueues.get(childID);
+    if (!browserQueue) {
+      return false;
+    }
+
+    this.crashedBrowserQueues.delete(childID);
+
+    let sentBrowser = false;
+    for (let weakBrowser of browserQueue) {
+      let browser = weakBrowser.get();
+      if (browser) {
+        if (
+          this.restartRequiredBrowsers.has(browser) ||
+          this.testBuildIDMismatch
+        ) {
+          this.sendToRestartRequiredPage(browser);
+        } else {
+          this.sendToTabCrashedPage(browser);
+        }
+        sentBrowser = true;
+      }
+    }
+
+    return sentBrowser;
+  },
+
+  /**
+   * Called by a tabbrowser when it notices that its selected browser
+   * has crashed. This will queue the browser to show the tab crash
+   * page once the content process has finished tearing down.
+   *
+   * @param browser (<xul:browser>)
+   *        The selected browser that just crashed.
+   * @param restartRequired (bool)
+   *        Whether or not a browser restart is required to recover.
+   */
+  onSelectedBrowserCrash(browser, restartRequired) {
+    if (!browser.isRemoteBrowser) {
+      console.error("Selected crashed browser is not remote.");
+      return;
+    }
+    if (!browser.frameLoader) {
+      console.error("Selected crashed browser has no frameloader.");
+      return;
+    }
+
+    let childID = browser.frameLoader.childID;
+
+    let browserQueue = this.crashedBrowserQueues.get(childID);
+    if (!browserQueue) {
+      browserQueue = [];
+      this.crashedBrowserQueues.set(childID, browserQueue);
+    }
+    // It's probably unnecessary to store this browser as a
+    // weak reference, since the content process should complete
+    // its teardown in the same tick of the event loop, and then
+    // this queue will be flushed. The weak reference is to avoid
+    // leaking browsers in case anything goes wrong during this
+    // teardown process.
+    browserQueue.push(Cu.getWeakReference(browser));
+
+    if (restartRequired) {
+      this.restartRequiredBrowsers.add(browser);
+    }
+
+    // In the event that the content process failed to launch, then
+    // the childID will be 0. In that case, we will never receive
+    // a dumpID nor an ipc:content-shutdown observer notification,
+    // so we should flush the queue for childID 0 immediately.
+    if (childID == 0) {
+      this.flushCrashedBrowserQueue(0);
+    }
+  },
+
+  /**
+   * Called by a tabbrowser when it notices that a background browser
+   * has crashed. This will flip its remoteness to non-remote, and attempt
+   * to revive the crashed tab so that upon selection the tab either shows
+   * an error page, or automatically restores.
+   *
+   * @param browser (<xul:browser>)
+   *        The background browser that just crashed.
+   * @param restartRequired (bool)
+   *        Whether or not a browser restart is required to recover.
+   */
+  onBackgroundBrowserCrash(browser, restartRequired) {
+    if (restartRequired) {
+      this.restartRequiredBrowsers.add(browser);
+    }
+
+    let gBrowser = browser.getTabBrowser();
+    let tab = gBrowser.getTabForBrowser(browser);
+
+    gBrowser.updateBrowserRemoteness(browser, {
+      remoteType: lazy.E10SUtils.NOT_REMOTE,
+    });
+
+    lazy.SessionStore.reviveCrashedTab(tab);
+  },
+
+  /**
+   * Called when a subframe crashes. If the dump is available, shows a subframe
+   * crashed notification, otherwise waits for one to be available.
+   *
+   * @param browser (<xul:browser>)
+   *        The browser containing the frame that just crashed.
+   * @param childId
+   *        The id of the process that just crashed.
+   */
+  async onSubFrameCrash(browser, childID) {
+    if (!AppConstants.MOZ_CRASHREPORTER) {
+      return;
+    }
+
+    // If a crash dump is available, use it. Otherwise, add the child id to the pending
+    // subframe crashes list, and wait for the crash "ipc:content-shutdown" notification
+    // to get the minidump. If it never arrives, don't show the notification.
+    let dumpID = this.childMap.get(childID);
+    if (dumpID) {
+      this.showSubFrameNotification(browser, childID, dumpID);
+    } else {
+      let item = this.pendingSubFrameCrashes.get(childID);
+      if (!item) {
+        item = new BrowserWeakMap();
+        this.pendingSubFrameCrashes.set(childID, item);
+
+        // Add the childID to an array that only has room for MAX_UNSEEN_CRASHED_SUBFRAME_IDS
+        // items. If there is no more room, pop the oldest off and remove it. This technique
+        // is used instead of a timeout.
+        if (
+          this.pendingSubFrameCrashesIDs.length >=
+          MAX_UNSEEN_CRASHED_SUBFRAME_IDS
+        ) {
+          let idToDelete = this.pendingSubFrameCrashesIDs.shift();
+          this.pendingSubFrameCrashes.delete(idToDelete);
+        }
+        this.pendingSubFrameCrashesIDs.push(childID);
+      }
+      item.set(browser, browser);
+    }
+  },
+
+  /**
+   * Given a childID, retrieve the subframe crash info for it
+   * from the pendingSubFrameCrashes map. The data is removed
+   * from the map and returned.
+   *
+   * @param childID number
+   *        childID of the content that crashed.
+   * @returns subframe crash info added by previous call to onSubFrameCrash.
+   */
+  getAndRemoveSubframeCrash(childID) {
+    let item = this.pendingSubFrameCrashes.get(childID);
+    if (item) {
+      this.pendingSubFrameCrashes.delete(childID);
+      let idx = this.pendingSubFrameCrashesIDs.indexOf(childID);
+      if (idx >= 0) {
+        this.pendingSubFrameCrashesIDs.splice(idx, 1);
+      }
+    }
+
+    return item;
+  },
+
+  /**
+   * Called to indicate that a subframe within a browser has crashed. A notification
+   * bar will be shown.
+   *
+   * @param browser (<xul:browser>)
+   *        The browser containing the frame that just crashed.
+   * @param childId
+   *        The id of the process that just crashed.
+   * @param dumpID
+   *        Minidump id of the crash.
+   */
+  async showSubFrameNotification(browser, childID, dumpID) {
+    let gBrowser = browser.getTabBrowser();
+    let notificationBox = gBrowser.getNotificationBox(browser);
+
+    const value = "subframe-crashed";
+    let notification = notificationBox.getNotificationWithValue(value);
+    if (notification) {
+      // Don't show multiple notifications for a browser.
+      return;
+    }
+
+    let closeAllNotifications = () => {
+      // Close all other notifications on other tabs that might
+      // be open for the same crashed process.
+      let existingItem = this.notificationsMap.get(childID);
+      if (existingItem) {
+        for (let notif of existingItem.slice()) {
+          notif.close();
+        }
+      }
+    };
+
+    gBrowser.ownerGlobal.MozXULElement.insertFTLIfNeeded(
+      "browser/contentCrash.ftl"
+    );
+
+    let buttons = [
+      {
+        "l10n-id": "crashed-subframe-learnmore-link",
+        popup: null,
+        link: SUBFRAMECRASH_LEARNMORE_URI,
+      },
+      {
+        "l10n-id": "crashed-subframe-submit",
+        popup: null,
+        callback: async () => {
+          if (dumpID) {
+            UnsubmittedCrashHandler.submitReports(
+              [dumpID],
+              lazy.CrashSubmit.SUBMITTED_FROM_CRASH_TAB
+            );
+          }
+          closeAllNotifications();
+        },
+      },
+    ];
+
+    notification = await notificationBox.appendNotification(
+      value,
+      {
+        label: { "l10n-id": "crashed-subframe-message" },
+        image: TABCRASHED_ICON_URI,
+        priority: notificationBox.PRIORITY_INFO_MEDIUM,
+        eventCallback: eventName => {
+          if (eventName == "disconnected") {
+            let existingItem = this.notificationsMap.get(childID);
+            if (existingItem) {
+              let idx = existingItem.indexOf(notification);
+              if (idx >= 0) {
+                existingItem.splice(idx, 1);
+              }
+
+              if (!existingItem.length) {
+                this.notificationsMap.delete(childID);
+              }
+            }
+          } else if (eventName == "dismissed") {
+            if (dumpID) {
+              lazy.CrashSubmit.ignore(dumpID);
+              this.childMap.delete(childID);
+            }
+
+            closeAllNotifications();
+          }
+        },
+      },
+      buttons
+    );
+
+    let existingItem = this.notificationsMap.get(childID);
+    if (existingItem) {
+      existingItem.push(notification);
+    } else {
+      this.notificationsMap.set(childID, [notification]);
+    }
+  },
+
+  /**
+   * This method is exposed for SessionStore to call if the user selects
+   * a tab which will restore on demand. It's possible that the tab
+   * is in this state because it recently crashed. If that's the case, then
+   * it's also possible that the user has not seen the tab crash page for
+   * that particular crash, in which case, we might show it to them instead
+   * of restoring the tab.
+   *
+   * @param browser (<xul:browser>)
+   *        A browser from a browser tab that the user has just selected
+   *        to restore on demand.
+   * @returns (boolean)
+   *        True if TabCrashHandler will send the user to the tab crash
+   *        page instead.
+   */
+  willShowCrashedTab(browser) {
+    let childID = this.browserMap.get(browser);
+    // We will only show the tab crash page if:
+    // 1) We are aware that this browser crashed
+    // 2) We know we've never shown the tab crash page for the
+    //    crash yet
+    // 3) The user is not configured to automatically submit backlogged
+    //    crash reports. If they are, we'll send the crash report
+    //    immediately.
+    if (childID && this.unseenCrashedChildIDs.includes(childID)) {
+      if (UnsubmittedCrashHandler.autoSubmit) {
+        let dumpID = this.childMap.get(childID);
+        if (dumpID) {
+          UnsubmittedCrashHandler.submitReports(
+            [dumpID],
+            lazy.CrashSubmit.SUBMITTED_FROM_AUTO
+          );
+        }
+      } else {
+        this.sendToTabCrashedPage(browser);
+        return true;
+      }
+    } else if (childID === 0) {
+      if (this.restartRequiredBrowsers.has(browser)) {
+        this.sendToRestartRequiredPage(browser);
+      } else {
+        this.sendToTabCrashedPage(browser);
+      }
+      return true;
+    }
+
+    return false;
+  },
+
+  sendToRestartRequiredPage(browser) {
+    let uri = browser.currentURI;
+    let gBrowser = browser.getTabBrowser();
+    let tab = gBrowser.getTabForBrowser(browser);
+    // The restart required page is non-remote by default.
+    gBrowser.updateBrowserRemoteness(browser, {
+      remoteType: lazy.E10SUtils.NOT_REMOTE,
+    });
+
+    browser.docShell.displayLoadError(Cr.NS_ERROR_BUILDID_MISMATCH, uri, null);
+    tab.setAttribute("crashed", true);
+    gBrowser.tabContainer.updateTabIndicatorAttr(tab);
+
+    // Make sure to only count once even if there are multiple windows
+    // that will all show about:restartrequired.
+    if (this._crashedTabCount == 1) {
+      Services.telemetry.scalarAdd("dom.contentprocess.buildID_mismatch", 1);
+    }
+  },
+
+  /**
+   * We show a special page to users when a normal browser tab has crashed.
+   * This method should be called to send a browser to that page once the
+   * process has completely closed.
+   *
+   * @param browser (<xul:browser>)
+   *        The browser that has recently crashed.
+   */
+  sendToTabCrashedPage(browser) {
+    let title = browser.contentTitle;
+    let uri = browser.currentURI;
+    let gBrowser = browser.getTabBrowser();
+    let tab = gBrowser.getTabForBrowser(browser);
+    // The tab crashed page is non-remote by default.
+    gBrowser.updateBrowserRemoteness(browser, {
+      remoteType: lazy.E10SUtils.NOT_REMOTE,
+    });
+
+    browser.setAttribute("crashedPageTitle", title);
+    browser.docShell.displayLoadError(Cr.NS_ERROR_CONTENT_CRASHED, uri, null);
+    browser.removeAttribute("crashedPageTitle");
+    tab.setAttribute("crashed", true);
+    gBrowser.tabContainer.updateTabIndicatorAttr(tab);
+  },
+
+  /**
+   * Submits a crash report from about:tabcrashed, if the crash
+   * reporter is enabled and a crash report can be found.
+   *
+   * @param browser
+   *        The <xul:browser> that the report was sent from.
+   * @param message
+   *        Message data with the following properties:
+   *
+   *        includeURL (bool):
+   *          Whether to include the URL that the user was on
+   *          in the crashed tab before the crash occurred.
+   *        URL (String)
+   *          The URL that the user was on in the crashed tab
+   *          before the crash occurred.
+   *        comments (String):
+   *          Any additional comments from the user.
+   *
+   *        Note that it is expected that all properties are set,
+   *        even if they are empty.
+   */
+  maybeSendCrashReport(browser, message) {
+    if (!AppConstants.MOZ_CRASHREPORTER) {
+      return;
+    }
+
+    if (!message.data.hasReport) {
+      // There was no report, so nothing to do.
+      return;
+    }
+
+    if (message.data.autoSubmit) {
+      // The user has opted in to autosubmitted backlogged
+      // crash reports in the future.
+      UnsubmittedCrashHandler.autoSubmit = true;
+    }
+
+    let childID = this.browserMap.get(browser);
+    let dumpID = this.childMap.get(childID);
+    if (!dumpID) {
+      return;
+    }
+
+    if (!message.data.sendReport) {
+      Services.telemetry
+        .getHistogramById("FX_CONTENT_CRASH_NOT_SUBMITTED")
+        .add(1);
+      this.prefs.setBoolPref("sendReport", false);
+      return;
+    }
+
+    let { includeURL, comments, URL } = message.data;
+
+    let extraExtraKeyVals = {
+      Comments: comments,
+      URL,
+    };
+
+    // For the entries in extraExtraKeyVals, we only want to submit the
+    // extra data values where they are not the empty string.
+    for (let key in extraExtraKeyVals) {
+      let val = extraExtraKeyVals[key].trim();
+      if (!val) {
+        delete extraExtraKeyVals[key];
+      }
+    }
+
+    // URL is special, since it's already been written to extra data by
+    // default. In order to make sure we don't send it, we overwrite it
+    // with the empty string.
+    if (!includeURL) {
+      extraExtraKeyVals.URL = "";
+    }
+
+    lazy.CrashSubmit.submit(dumpID, lazy.CrashSubmit.SUBMITTED_FROM_CRASH_TAB, {
+      recordSubmission: true,
+      extraExtraKeyVals,
+    }).catch(console.error);
+
+    this.prefs.setBoolPref("sendReport", true);
+    this.prefs.setBoolPref("includeURL", includeURL);
+
+    this.childMap.set(childID, null); // Avoid resubmission.
+    this.removeSubmitCheckboxesForSameCrash(childID);
+  },
+
+  removeSubmitCheckboxesForSameCrash(childID) {
+    for (let window of Services.wm.getEnumerator("navigator:browser")) {
+      if (!window.gMultiProcessBrowser) {
+        continue;
+      }
+
+      for (let browser of window.gBrowser.browsers) {
+        if (browser.isRemoteBrowser) {
+          continue;
+        }
+
+        let doc = browser.contentDocument;
+        if (!doc.documentURI.startsWith("about:tabcrashed")) {
+          continue;
+        }
+
+        if (this.browserMap.get(browser) == childID) {
+          this.browserMap.delete(browser);
+          browser.sendMessageToActor("CrashReportSent", {}, "AboutTabCrashed");
+        }
+      }
+    }
+  },
+
+  /**
+   * Process a crashed tab loaded into a browser.
+   *
+   * @param browser
+   *        The <xul:browser> containing the page that crashed.
+   * @returns crash data
+   *        Message data containing information about the crash.
+   */
+  onAboutTabCrashedLoad(browser) {
+    this._crashedTabCount++;
+
+    let window = browser.ownerGlobal;
+
+    // Reset the zoom for the tabcrashed page.
+    window.ZoomManager.setZoomForBrowser(browser, 1);
+
+    let childID = this.browserMap.get(browser);
+    let index = this.unseenCrashedChildIDs.indexOf(childID);
+    if (index != -1) {
+      this.unseenCrashedChildIDs.splice(index, 1);
+    }
+
+    let dumpID = this.getDumpID(browser);
+    if (!dumpID) {
+      return {
+        hasReport: false,
+      };
+    }
+
+    let requestAutoSubmit = !UnsubmittedCrashHandler.autoSubmit;
+    let sendReport = this.prefs.getBoolPref("sendReport");
+    let includeURL = this.prefs.getBoolPref("includeURL");
+
+    let data = {
+      hasReport: true,
+      sendReport,
+      includeURL,
+      requestAutoSubmit,
+    };
+
+    return data;
+  },
+
+  onAboutTabCrashedUnload(browser) {
+    if (!this._crashedTabCount) {
+      console.error("Can not decrement crashed tab count to below 0");
+      return;
+    }
+    this._crashedTabCount--;
+
+    let childID = this.browserMap.get(browser);
+
+    // Make sure to only count once even if there are multiple windows
+    // that will all show about:tabcrashed.
+    if (this._crashedTabCount == 0 && childID) {
+      Services.telemetry
+        .getHistogramById("FX_CONTENT_CRASH_NOT_SUBMITTED")
+        .add(1);
+    }
+  },
+
+  /**
+   * For some <xul:browser>, return a crash report dump ID for that browser
+   * if we have been informed of one. Otherwise, return null.
+   *
+   * @param browser (<xul:browser)
+   *        The browser to try to get the dump ID for
+   * @returns dumpID (String)
+   */
+  getDumpID(browser) {
+    if (!AppConstants.MOZ_CRASHREPORTER) {
+      return null;
+    }
+
+    return this.childMap.get(this.browserMap.get(browser));
+  },
+
+  /**
+   * This is intended for TESTING ONLY. It returns the amount of
+   * content processes that have crashed such that we're still waiting
+   * for dump IDs for their crash reports.
+   *
+   * For our automated tests, accessing the crashed content process
+   * count helps us test the behaviour when content processes crash due
+   * to launch failure, since in those cases we should not increase the
+   * crashed browser queue (since we never receive dump IDs for launch
+   * failures).
+   */
+  get queuedCrashedBrowsers() {
+    return this.crashedBrowserQueues.size;
+  },
+};
+
+/**
+ * This component is responsible for scanning the pending
+ * crash report directory for reports, and (if enabled), to
+ * prompt the user to submit those reports. It might also
+ * submit those reports automatically without prompting if
+ * the user has opted in.
+ */
+export var UnsubmittedCrashHandler = {
+  get prefs() {
+    delete this.prefs;
+    return (this.prefs = Services.prefs.getBranch(
+      "browser.crashReports.unsubmittedCheck."
+    ));
+  },
+
+  get enabled() {
+    return this.prefs.getBoolPref("enabled");
+  },
+
+  // showingNotification is set to true once a notification
+  // is successfully shown, and then set back to false if
+  // the notification is dismissed by an action by the user.
+  showingNotification: false,
+  // suppressed is true if we've determined that we've shown
+  // the notification too many times across too many days without
+  // user interaction, so we're suppressing the notification for
+  // some number of days. See the documentation for
+  // shouldShowPendingSubmissionsNotification().
+  suppressed: false,
+
+  _checkTimeout: null,
+
+  init() {
+    if (this.initialized) {
+      return;
+    }
+
+    this.initialized = true;
+
+    // UnsubmittedCrashHandler can be initialized but still be disabled.
+    // This is intentional, as this makes simulating UnsubmittedCrashHandler's
+    // reactions to browser startup and shutdown easier in test automation.
+    //
+    // UnsubmittedCrashHandler, when initialized but not enabled, is inert.
+    if (this.enabled) {
+      if (this.prefs.prefHasUserValue("suppressUntilDate")) {
+        if (this.prefs.getCharPref("suppressUntilDate") > this.dateString()) {
+          // We'll be suppressing any notifications until after suppressedDate,
+          // so there's no need to do anything more.
+          this.suppressed = true;
+          return;
+        }
+
+        // We're done suppressing, so we don't need this pref anymore.
+        this.prefs.clearUserPref("suppressUntilDate");
+      }
+
+      Services.obs.addObserver(this, "profile-before-change");
+    }
+  },
+
+  uninit() {
+    if (!this.initialized) {
+      return;
+    }
+
+    this.initialized = false;
+
+    if (this._checkTimeout) {
+      lazy.clearTimeout(this._checkTimeout);
+      this._checkTimeout = null;
+    }
+
+    if (!this.enabled) {
+      return;
+    }
+
+    if (this.suppressed) {
+      this.suppressed = false;
+      // No need to do any more clean-up, since we were suppressed.
+      return;
+    }
+
+    if (this.showingNotification) {
+      this.prefs.setBoolPref("shutdownWhileShowing", true);
+      this.showingNotification = false;
+    }
+
+    Services.obs.removeObserver(this, "profile-before-change");
+  },
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case "profile-before-change": {
+        this.uninit();
+        break;
+      }
+    }
+  },
+
+  scheduleCheckForUnsubmittedCrashReports() {
+    this._checkTimeout = lazy.setTimeout(() => {
+      Services.tm.idleDispatchToMainThread(() => {
+        this.checkForUnsubmittedCrashReports();
+      });
+    }, CHECK_FOR_UNSUBMITTED_CRASH_REPORTS_DELAY_MS);
+  },
+
+  /**
+   * Scans the profile directory for unsubmitted crash reports
+   * within the past PENDING_CRASH_REPORT_DAYS days. If it
+   * finds any, it will, if necessary, attempt to open a notification
+   * bar to prompt the user to submit them.
+   *
+   * @returns Promise
+   *          Resolves with the <xul:notification> after it tries to
+   *          show a notification on the most recent browser window.
+   *          If a notification cannot be shown, will resolve with null.
+   */
+  async checkForUnsubmittedCrashReports() {
+    if (!this.enabled || this.suppressed) {
+      return null;
+    }
+
+    let dateLimit = new Date();
+    dateLimit.setDate(dateLimit.getDate() - PENDING_CRASH_REPORT_DAYS);
+
+    let reportIDs = [];
+    try {
+      reportIDs = await lazy.CrashSubmit.pendingIDs(dateLimit);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+
+    if (reportIDs.length) {
+      if (this.autoSubmit) {
+        this.submitReports(reportIDs, lazy.CrashSubmit.SUBMITTED_FROM_AUTO);
+      } else if (this.shouldShowPendingSubmissionsNotification()) {
+        return this.showPendingSubmissionsNotification(reportIDs);
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Returns true if the notification should be shown.
+   * shouldShowPendingSubmissionsNotification makes this decision
+   * by looking at whether or not the user has seen the notification
+   * over several days without ever interacting with it. If this occurs
+   * too many times, we suppress the notification for DAYS_TO_SUPPRESS
+   * days.
+   *
+   * @returns bool
+   */
+  shouldShowPendingSubmissionsNotification() {
+    if (!this.prefs.prefHasUserValue("shutdownWhileShowing")) {
+      return true;
+    }
+
+    let shutdownWhileShowing = this.prefs.getBoolPref("shutdownWhileShowing");
+    this.prefs.clearUserPref("shutdownWhileShowing");
+
+    if (!this.prefs.prefHasUserValue("lastShownDate")) {
+      // This isn't expected, but we're being defensive here. We'll
+      // opt for showing the notification in this case.
+      return true;
+    }
+
+    let lastShownDate = this.prefs.getCharPref("lastShownDate");
+    if (this.dateString() > lastShownDate && shutdownWhileShowing) {
+      // We're on a newer day then when we last showed the
+      // notification without closing it. We don't want to do
+      // this too many times, so we'll decrement a counter for
+      // this situation. Too many of these, and we'll assume the
+      // user doesn't know or care about unsubmitted notifications,
+      // and we'll suppress the notification for a while.
+      let chances = this.prefs.getIntPref("chancesUntilSuppress");
+      if (--chances < 0) {
+        // We're out of chances!
+        this.prefs.clearUserPref("chancesUntilSuppress");
+        // We'll suppress for DAYS_TO_SUPPRESS days.
+        let suppressUntil = this.dateString(
+          new Date(Date.now() + DAY * DAYS_TO_SUPPRESS)
+        );
+        this.prefs.setCharPref("suppressUntilDate", suppressUntil);
+        return false;
+      }
+      this.prefs.setIntPref("chancesUntilSuppress", chances);
+    }
+
+    return true;
+  },
+
+  /**
+   * Given an array of unsubmitted crash report IDs, try to open
+   * up a notification asking the user to submit them.
+   *
+   * @param reportIDs (Array<string>)
+   *        The Array of report IDs to offer the user to send.
+   * @returns The <xul:notification> if one is shown. null otherwise.
+   */
+  async showPendingSubmissionsNotification(reportIDs) {
+    if (!reportIDs.length) {
+      return null;
+    }
+
+    let notification = await this.show({
+      notificationID: "pending-crash-reports",
+      reportIDs,
+      onAction: () => {
+        this.showingNotification = false;
+      },
+    });
+
+    if (notification) {
+      this.showingNotification = true;
+      this.prefs.setCharPref("lastShownDate", this.dateString());
+    }
+
+    return notification;
+  },
+
+  /**
+   * Returns a string representation of a Date in the format
+   * YYYYMMDD.
+   *
+   * @param someDate (Date, optional)
+   *        The Date to convert to the string. If not provided,
+   *        defaults to today's date.
+   * @returns String
+   */
+  dateString(someDate = new Date()) {
+    let year = String(someDate.getFullYear()).padStart(4, "0");
+    let month = String(someDate.getMonth() + 1).padStart(2, "0");
+    let day = String(someDate.getDate()).padStart(2, "0");
+    return year + month + day;
+  },
+
+  /**
+   * Attempts to show a notification bar to the user in the most
+   * recent browser window asking them to submit some crash report
+   * IDs. If a notification cannot be shown (for example, there
+   * is no browser window), this method exits silently.
+   *
+   * The notification will allow the user to submit their crash
+   * reports. If the user dismissed the notification, the crash
+   * reports will be marked to be ignored (though they can
+   * still be manually submitted via about:crashes).
+   *
+   * @param JS Object
+   *        An Object with the following properties:
+   *
+   *        notificationID (string)
+   *          The ID for the notification to be opened.
+   *
+   *        reportIDs (Array<string>)
+   *          The array of report IDs to offer to the user.
+   *
+   *        onAction (function, optional)
+   *          A callback to fire once the user performs an
+   *          action on the notification bar (this includes
+   *          dismissing the notification).
+   *
+   * @returns The <xul:notification> if one is shown. null otherwise.
+   */
+  show({ notificationID, reportIDs, onAction }) {
+    let chromeWin = lazy.BrowserWindowTracker.getTopWindow();
+    if (!chromeWin) {
+      // Can't show a notification in this case. We'll hopefully
+      // get another opportunity to have the user submit their
+      // crash reports later.
+      return null;
+    }
+
+    let notification =
+      chromeWin.gNotificationBox.getNotificationWithValue(notificationID);
+    if (notification) {
+      return null;
+    }
+
+    chromeWin.MozXULElement.insertFTLIfNeeded("browser/contentCrash.ftl");
+
+    let buttons = [
+      {
+        "l10n-id": "pending-crash-reports-send",
+        callback: () => {
+          this.submitReports(
+            reportIDs,
+            lazy.CrashSubmit.SUBMITTED_FROM_INFOBAR
+          );
+          if (onAction) {
+            onAction();
+          }
+        },
+      },
+      {
+        "l10n-id": "pending-crash-reports-always-send",
+        callback: () => {
+          this.autoSubmit = true;
+          this.submitReports(
+            reportIDs,
+            lazy.CrashSubmit.SUBMITTED_FROM_INFOBAR
+          );
+          if (onAction) {
+            onAction();
+          }
+        },
+      },
+      {
+        "l10n-id": "pending-crash-reports-view-all",
+        callback() {
+          chromeWin.openTrustedLinkIn("about:crashes", "tab");
+          return true;
+        },
+      },
+    ];
+
+    let eventCallback = eventType => {
+      if (eventType == "dismissed") {
+        // The user intentionally dismissed the notification,
+        // which we interpret as meaning that they don't care
+        // to submit the reports. We'll ignore these particular
+        // reports going forward.
+        reportIDs.forEach(function (reportID) {
+          lazy.CrashSubmit.ignore(reportID);
+        });
+        if (onAction) {
+          onAction();
+        }
+      }
+    };
+
+    return chromeWin.gNotificationBox.appendNotification(
+      notificationID,
+      {
+        label: {
+          "l10n-id": "pending-crash-reports-message",
+          "l10n-args": { reportCount: reportIDs.length },
+        },
+        image: TABCRASHED_ICON_URI,
+        priority: chromeWin.gNotificationBox.PRIORITY_INFO_HIGH,
+        eventCallback,
+      },
+      buttons
+    );
+  },
+
+  get autoSubmit() {
+    return Services.prefs.getBoolPref(
+      "browser.crashReports.unsubmittedCheck.autoSubmit2"
+    );
+  },
+
+  set autoSubmit(val) {
+    Services.prefs.setBoolPref(
+      "browser.crashReports.unsubmittedCheck.autoSubmit2",
+      val
+    );
+  },
+
+  /**
+   * Attempt to submit reports to the crash report server.
+   *
+   * @param reportIDs (Array<string>)
+   *        The array of reportIDs to submit.
+   * @param submittedFrom (string)
+   *        One of the CrashSubmit.SUBMITTED_FROM_* constants representing
+   *        how this crash was submitted.
+   */
+  submitReports(reportIDs, submittedFrom) {
+    for (let reportID of reportIDs) {
+      lazy.CrashSubmit.submit(reportID, submittedFrom).catch(console.error);
+    }
+  },
+};
diff --git a/browser/modules/Discovery.sys.mjs b/browser/modules/Discovery.sys.mjs
new file mode 100644
index 0000000000..abd9cb21cb
--- /dev/null
+++ b/browser/modules/Discovery.sys.mjs
@@ -0,0 +1,151 @@
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ClientID: "resource://gre/modules/ClientID.sys.mjs",
+  ContextualIdentityService:
+    "resource://gre/modules/ContextualIdentityService.sys.mjs",
+});
+
+const RECOMMENDATION_ENABLED = "browser.discovery.enabled";
+const TELEMETRY_ENABLED = "datareporting.healthreport.uploadEnabled";
+const TAAR_COOKIE_NAME = "taarId";
+
+export const Discovery = {
+  set enabled(val) {
+    val = !!val;
+    if (val && !lazy.gTelemetryEnabled) {
+      throw Error("unable to turn on recommendations");
+    }
+    Services.prefs.setBoolPref(RECOMMENDATION_ENABLED, val);
+  },
+
+  get enabled() {
+    return lazy.gTelemetryEnabled && lazy.gRecommendationEnabled;
+  },
+
+  reset() {
+    return DiscoveryInternal.update(true);
+  },
+
+  update() {
+    return DiscoveryInternal.update();
+  },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gRecommendationEnabled",
+  RECOMMENDATION_ENABLED,
+  false,
+  Discovery.update
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gTelemetryEnabled",
+  TELEMETRY_ENABLED,
+  false,
+  Discovery.update
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gCachedClientID",
+  "toolkit.telemetry.cachedClientID",
+  "",
+  Discovery.reset
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gContainersEnabled",
+  "browser.discovery.containers.enabled",
+  false,
+  Discovery.reset
+);
+
+Services.obs.addObserver(Discovery.update, "contextual-identity-created");
+
+const DiscoveryInternal = {
+  get sites() {
+    delete this.sites;
+    this.sites = Services.prefs
+      .getCharPref("browser.discovery.sites", "")
+      .split(",");
+    return this.sites;
+  },
+
+  getContextualIDs() {
+    // There is never a zero id, this is just for use in update.
+    let IDs = [0];
+    if (lazy.gContainersEnabled) {
+      lazy.ContextualIdentityService.getPublicIdentities().forEach(identity => {
+        IDs.push(identity.userContextId);
+      });
+    }
+    return IDs;
+  },
+
+  async update(reset = false) {
+    if (reset || !Discovery.enabled) {
+      for (let site of this.sites) {
+        Services.cookies.remove(site, TAAR_COOKIE_NAME, "/", {});
+        lazy.ContextualIdentityService.getPublicIdentities().forEach(
+          identity => {
+            let { userContextId } = identity;
+            Services.cookies.remove(site, TAAR_COOKIE_NAME, "/", {
+              userContextId,
+            });
+          }
+        );
+      }
+    }
+
+    if (Discovery.enabled) {
+      // If the client id is not cached, wait for the notification that it is
+      // cached.  This will happen shortly after startup in TelemetryController.sys.mjs.
+      // When that happens, we'll get a pref notification for the cached id,
+      // which will call update again.
+      if (!lazy.gCachedClientID) {
+        return;
+      }
+      let id = await lazy.ClientID.getClientIdHash();
+      for (let site of this.sites) {
+        // This cookie gets tied down as much as possible.  Specifically,
+        // SameSite, Secure, HttpOnly and non-PrivateBrowsing.
+        for (let userContextId of this.getContextualIDs()) {
+          let originAttributes = { privateBrowsingId: 0 };
+          if (userContextId > 0) {
+            originAttributes.userContextId = userContextId;
+          }
+          if (
+            Services.cookies.cookieExists(
+              site,
+              "/",
+              TAAR_COOKIE_NAME,
+              originAttributes
+            )
+          ) {
+            continue;
+          }
+          Services.cookies.add(
+            site,
+            "/",
+            TAAR_COOKIE_NAME,
+            id,
+            true, // secure
+            true, // httpOnly
+            true, // session
+            Date.now(),
+            originAttributes,
+            Ci.nsICookie.SAMESITE_LAX,
+            Ci.nsICookie.SCHEME_HTTPS
+          );
+        }
+      }
+    }
+  },
+};
diff --git a/browser/modules/EveryWindow.sys.mjs b/browser/modules/EveryWindow.sys.mjs
new file mode 100644
index 0000000000..704240b54f
--- /dev/null
+++ b/browser/modules/EveryWindow.sys.mjs
@@ -0,0 +1,114 @@
+/* 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/. */
+
+/*
+ * This module enables consumers to register callbacks on every
+ * current and future browser window.
+ *
+ * Usage: EveryWindow.registerCallback(id, init, uninit);
+ *        EveryWindow.unregisterCallback(id);
+ *
+ * id is expected to be a unique value that identifies the
+ * consumer, to be used for unregistration. If the id is already
+ * in use, registerCallback returns false without doing anything.
+ *
+ * Each callback will receive the window for which it is presently
+ * being called as the first argument.
+ *
+ * init is called on every existing window at the time of registration,
+ * and on all future windows at browser-delayed-startup-finished.
+ *
+ * uninit is called on every existing window if requested at the time
+ * of unregistration, and at the time of domwindowclosed.
+ * If the window is closing, a second argument is passed with value `true`.
+ */
+
+var initialized = false;
+var callbacks = new Map();
+
+function callForEveryWindow(callback) {
+  let windowList = Services.wm.getEnumerator("navigator:browser");
+  for (let win of windowList) {
+    win.delayedStartupPromise.then(() => {
+      callback(win);
+    });
+  }
+}
+
+export const EveryWindow = {
+  /**
+   * The current list of all browser windows whose delayedStartupPromise has resolved
+   */
+  get readyWindows() {
+    return Array.from(Services.wm.getEnumerator("navigator:browser")).filter(
+      win => win.gBrowserInit?.delayedStartupFinished
+    );
+  },
+
+  /**
+   * Registers init and uninit functions to be called on every window.
+   *
+   * @param {string} id A unique identifier for the consumer, to be
+   *   used for unregistration.
+   * @param {function} init The function to be called on every currently
+   *   existing window and every future window after delayed startup.
+   * @param {function} uninit The function to be called on every window
+   *   at the time of callback unregistration or after domwindowclosed.
+   * @returns {boolean} Returns false if the id was taken, else true.
+   */
+  registerCallback: function EW_registerCallback(id, init, uninit) {
+    if (callbacks.has(id)) {
+      return false;
+    }
+
+    if (!initialized) {
+      let addUnloadListener = win => {
+        function observer(subject, topic, data) {
+          if (topic == "domwindowclosed" && subject === win) {
+            Services.ww.unregisterNotification(observer);
+            for (let c of callbacks.values()) {
+              c.uninit(win, true);
+            }
+          }
+        }
+        Services.ww.registerNotification(observer);
+      };
+
+      Services.obs.addObserver(win => {
+        for (let c of callbacks.values()) {
+          c.init(win);
+        }
+        addUnloadListener(win);
+      }, "browser-delayed-startup-finished");
+
+      callForEveryWindow(addUnloadListener);
+
+      initialized = true;
+    }
+
+    callForEveryWindow(init);
+    callbacks.set(id, { id, init, uninit });
+
+    return true;
+  },
+
+  /**
+   * Unregisters a previously registered consumer.
+   *
+   * @param {string} id The id to unregister.
+   * @param {boolean} [callUninit=true] Whether to call the registered uninit
+   *   function on every window.
+   */
+  unregisterCallback: function EW_unregisterCallback(id, callUninit = true) {
+    if (!callbacks.has(id)) {
+      return;
+    }
+
+    if (callUninit) {
+      callForEveryWindow(callbacks.get(id).uninit);
+    }
+
+    callbacks.delete(id);
+  },
+};
diff --git a/browser/modules/ExtensionsUI.sys.mjs b/browser/modules/ExtensionsUI.sys.mjs
new file mode 100644
index 0000000000..0b113f87ce
--- /dev/null
+++ b/browser/modules/ExtensionsUI.sys.mjs
@@ -0,0 +1,719 @@
+/* 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/. */
+
+import { EventEmitter } from "resource://gre/modules/EventEmitter.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AMBrowserExtensionsImport: "resource://gre/modules/AddonManager.sys.mjs",
+  AMTelemetry: "resource://gre/modules/AddonManager.sys.mjs",
+  AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
+  AddonManagerPrivate: "resource://gre/modules/AddonManager.sys.mjs",
+  AppMenuNotifications: "resource://gre/modules/AppMenuNotifications.sys.mjs",
+  ExtensionData: "resource://gre/modules/Extension.sys.mjs",
+  ExtensionPermissions: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  OriginControls: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+  QuarantinedDomains: "resource://gre/modules/ExtensionPermissions.sys.mjs",
+});
+
+ChromeUtils.defineLazyGetter(
+  lazy,
+  "l10n",
+  () =>
+    new Localization(["browser/extensionsUI.ftl", "branding/brand.ftl"], true)
+);
+
+const DEFAULT_EXTENSION_ICON =
+  "chrome://mozapps/skin/extensions/extensionGeneric.svg";
+
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+
+function getTabBrowser(browser) {
+  while (browser.ownerGlobal.docShell.itemType !== Ci.nsIDocShell.typeChrome) {
+    browser = browser.ownerGlobal.docShell.chromeEventHandler;
+  }
+  let window = browser.ownerGlobal;
+  let viewType = browser.getAttribute("webextension-view-type");
+  if (viewType == "sidebar") {
+    window = window.browsingContext.topChromeWindow;
+  }
+  if (viewType == "popup" || viewType == "sidebar") {
+    browser = window.gBrowser.selectedBrowser;
+  }
+  return { browser, window };
+}
+
+export var ExtensionsUI = {
+  sideloaded: new Set(),
+  updates: new Set(),
+  sideloadListener: null,
+
+  pendingNotifications: new WeakMap(),
+
+  async init() {
+    Services.obs.addObserver(this, "webextension-permission-prompt");
+    Services.obs.addObserver(this, "webextension-update-permissions");
+    Services.obs.addObserver(this, "webextension-install-notify");
+    Services.obs.addObserver(this, "webextension-optional-permission-prompt");
+    Services.obs.addObserver(this, "webextension-defaultsearch-prompt");
+    Services.obs.addObserver(this, "webextension-imported-addons-cancelled");
+    Services.obs.addObserver(this, "webextension-imported-addons-complete");
+    Services.obs.addObserver(this, "webextension-imported-addons-pending");
+
+    await Services.wm.getMostRecentWindow("navigator:browser")
+      .delayedStartupPromise;
+
+    this._checkForSideloaded();
+  },
+
+  async _checkForSideloaded() {
+    let sideloaded = await lazy.AddonManagerPrivate.getNewSideloads();
+
+    if (!sideloaded.length) {
+      // No new side-loads. We're done.
+      return;
+    }
+
+    // The ordering shouldn't matter, but tests depend on notifications
+    // happening in a specific order.
+    sideloaded.sort((a, b) => a.id.localeCompare(b.id));
+
+    if (!this.sideloadListener) {
+      this.sideloadListener = {
+        onEnabled: addon => {
+          if (!this.sideloaded.has(addon)) {
+            return;
+          }
+
+          this.sideloaded.delete(addon);
+          this._updateNotifications();
+
+          if (this.sideloaded.size == 0) {
+            lazy.AddonManager.removeAddonListener(this.sideloadListener);
+            this.sideloadListener = null;
+          }
+        },
+      };
+      lazy.AddonManager.addAddonListener(this.sideloadListener);
+    }
+
+    for (let addon of sideloaded) {
+      this.sideloaded.add(addon);
+    }
+    this._updateNotifications();
+  },
+
+  _updateNotifications() {
+    const { sideloaded, updates } = this;
+    const { importedAddonIDs } = lazy.AMBrowserExtensionsImport;
+
+    if (importedAddonIDs.length + sideloaded.size + updates.size == 0) {
+      lazy.AppMenuNotifications.removeNotification("addon-alert");
+    } else {
+      lazy.AppMenuNotifications.showBadgeOnlyNotification("addon-alert");
+    }
+    this.emit("change");
+  },
+
+  showAddonsManager(tabbrowser, strings, icon) {
+    let global = tabbrowser.selectedBrowser.ownerGlobal;
+    return global
+      .BrowserOpenAddonsMgr("addons://list/extension")
+      .then(aomWin => {
+        let aomBrowser = aomWin.docShell.chromeEventHandler;
+        return this.showPermissionsPrompt(aomBrowser, strings, icon);
+      });
+  },
+
+  showSideloaded(tabbrowser, addon) {
+    addon.markAsSeen();
+    this.sideloaded.delete(addon);
+    this._updateNotifications();
+
+    let strings = this._buildStrings({
+      addon,
+      permissions: addon.userPermissions,
+      type: "sideload",
+    });
+
+    lazy.AMTelemetry.recordManageEvent(addon, "sideload_prompt", {
+      num_strings: strings.msgs.length,
+    });
+
+    this.showAddonsManager(tabbrowser, strings, addon.iconURL).then(
+      async answer => {
+        if (answer) {
+          await addon.enable();
+
+          this._updateNotifications();
+
+          // The user has just enabled a sideloaded extension, if the permission
+          // can be changed for the extension, show the post-install panel to
+          // give the user that opportunity.
+          if (
+            addon.permissions &
+            lazy.AddonManager.PERM_CAN_CHANGE_PRIVATEBROWSING_ACCESS
+          ) {
+            this.showInstallNotification(tabbrowser.selectedBrowser, addon);
+          }
+        }
+        this.emit("sideload-response");
+      }
+    );
+  },
+
+  showUpdate(browser, info) {
+    lazy.AMTelemetry.recordInstallEvent(info.install, {
+      step: "permissions_prompt",
+      num_strings: info.strings.msgs.length,
+    });
+
+    this.showAddonsManager(browser, info.strings, info.addon.iconURL).then(
+      answer => {
+        if (answer) {
+          info.resolve();
+        } else {
+          info.reject();
+        }
+        // At the moment, this prompt will re-appear next time we do an update
+        // check.  See bug 1332360 for proposal to avoid this.
+        this.updates.delete(info);
+        this._updateNotifications();
+      }
+    );
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "webextension-permission-prompt") {
+      let { target, info } = subject.wrappedJSObject;
+
+      let { browser, window } = getTabBrowser(target);
+
+      // Dismiss the progress notification.  Note that this is bad if
+      // there are multiple simultaneous installs happening, see
+      // bug 1329884 for a longer explanation.
+      let progressNotification = window.PopupNotifications.getNotification(
+        "addon-progress",
+        browser
+      );
+      if (progressNotification) {
+        progressNotification.remove();
+      }
+
+      info.unsigned =
+        info.addon.signedState <= lazy.AddonManager.SIGNEDSTATE_MISSING;
+      if (
+        info.unsigned &&
+        Cu.isInAutomation &&
+        Services.prefs.getBoolPref("extensions.ui.ignoreUnsigned", false)
+      ) {
+        info.unsigned = false;
+      }
+
+      let strings = this._buildStrings(info);
+
+      // If this is an update with no promptable permissions, just apply it
+      if (info.type == "update" && !strings.msgs.length) {
+        info.resolve();
+        return;
+      }
+
+      let icon = info.unsigned
+        ? "chrome://global/skin/icons/warning.svg"
+        : info.icon;
+
+      if (info.type == "sideload") {
+        lazy.AMTelemetry.recordManageEvent(info.addon, "sideload_prompt", {
+          num_strings: strings.msgs.length,
+        });
+      } else {
+        lazy.AMTelemetry.recordInstallEvent(info.install, {
+          step: "permissions_prompt",
+          num_strings: strings.msgs.length,
+        });
+      }
+
+      this.showPermissionsPrompt(browser, strings, icon).then(answer => {
+        if (answer) {
+          info.resolve();
+        } else {
+          info.reject();
+        }
+      });
+    } else if (topic == "webextension-update-permissions") {
+      let info = subject.wrappedJSObject;
+      info.type = "update";
+      let strings = this._buildStrings(info);
+
+      // If we don't prompt for any new permissions, just apply it
+      if (!strings.msgs.length) {
+        info.resolve();
+        return;
+      }
+
+      let update = {
+        strings,
+        permissions: info.permissions,
+        install: info.install,
+        addon: info.addon,
+        resolve: info.resolve,
+        reject: info.reject,
+      };
+
+      this.updates.add(update);
+      this._updateNotifications();
+    } else if (topic == "webextension-install-notify") {
+      let { target, addon, callback } = subject.wrappedJSObject;
+      this.showInstallNotification(target, addon).then(() => {
+        if (callback) {
+          callback();
+        }
+      });
+    } else if (topic == "webextension-optional-permission-prompt") {
+      let { browser, name, icon, permissions, resolve } =
+        subject.wrappedJSObject;
+      let strings = this._buildStrings({
+        type: "optional",
+        addon: { name },
+        permissions,
+      });
+
+      // If we don't have any promptable permissions, just proceed
+      if (!strings.msgs.length) {
+        resolve(true);
+        return;
+      }
+      resolve(this.showPermissionsPrompt(browser, strings, icon));
+    } else if (topic == "webextension-defaultsearch-prompt") {
+      let { browser, name, icon, respond, currentEngine, newEngine } =
+        subject.wrappedJSObject;
+
+      const [searchDesc, searchYes, searchNo] = lazy.l10n.formatMessagesSync([
+        {
+          id: "webext-default-search-description",
+          args: { addonName: "<>", currentEngine, newEngine },
+        },
+        "webext-default-search-yes",
+        "webext-default-search-no",
+      ]);
+
+      const strings = { addonName: name, text: searchDesc.value };
+      for (let attr of searchYes.attributes) {
+        if (attr.name === "label") {
+          strings.acceptText = attr.value;
+        } else if (attr.name === "accesskey") {
+          strings.acceptKey = attr.value;
+        }
+      }
+      for (let attr of searchNo.attributes) {
+        if (attr.name === "label") {
+          strings.cancelText = attr.value;
+        } else if (attr.name === "accesskey") {
+          strings.cancelKey = attr.value;
+        }
+      }
+
+      this.showDefaultSearchPrompt(browser, strings, icon).then(respond);
+    } else if (
+      [
+        "webextension-imported-addons-cancelled",
+        "webextension-imported-addons-complete",
+        "webextension-imported-addons-pending",
+      ].includes(topic)
+    ) {
+      this._updateNotifications();
+    }
+  },
+
+  // Create a set of formatted strings for a permission prompt
+  _buildStrings(info) {
+    const strings = lazy.ExtensionData.formatPermissionStrings(info, {
+      collapseOrigins: true,
+    });
+    strings.addonName = info.addon.name;
+    return strings;
+  },
+
+  async showPermissionsPrompt(target, strings, icon) {
+    let { browser, window } = getTabBrowser(target);
+
+    await window.ensureCustomElements("moz-support-link");
+
+    // Wait for any pending prompts to complete before showing the next one.
+    let pending;
+    while ((pending = this.pendingNotifications.get(browser))) {
+      await pending;
+    }
+
+    let promise = new Promise(resolve => {
+      function eventCallback(topic) {
+        let doc = this.browser.ownerDocument;
+        if (topic == "showing") {
+          let textEl = doc.getElementById("addon-webext-perm-text");
+          textEl.textContent = strings.text;
+          textEl.hidden = !strings.text;
+
+          // By default, multiline strings don't get formatted properly. These
+          // are presently only used in site permission add-ons, so we treat it
+          // as a special case to avoid unintended effects on other things.
+          let isMultiline = strings.text.includes("\n\n");
+          textEl.classList.toggle(
+            "addon-webext-perm-text-multiline",
+            isMultiline
+          );
+
+          let listIntroEl = doc.getElementById("addon-webext-perm-intro");
+          listIntroEl.textContent = strings.listIntro;
+          listIntroEl.hidden = !strings.msgs.length || !strings.listIntro;
+
+          let listInfoEl = doc.getElementById("addon-webext-perm-info");
+          listInfoEl.hidden = !strings.msgs.length;
+
+          let list = doc.getElementById("addon-webext-perm-list");
+          while (list.firstChild) {
+            list.firstChild.remove();
+          }
+          let singleEntryEl = doc.getElementById(
+            "addon-webext-perm-single-entry"
+          );
+          singleEntryEl.textContent = "";
+          singleEntryEl.hidden = true;
+          list.hidden = true;
+
+          if (strings.msgs.length === 1) {
+            singleEntryEl.textContent = strings.msgs[0];
+            singleEntryEl.hidden = false;
+          } else if (strings.msgs.length) {
+            for (let msg of strings.msgs) {
+              let item = doc.createElementNS(HTML_NS, "li");
+              item.textContent = msg;
+              list.appendChild(item);
+            }
+            list.hidden = false;
+          }
+        } else if (topic == "swapping") {
+          return true;
+        }
+        if (topic == "removed") {
+          Services.tm.dispatchToMainThread(() => {
+            resolve(false);
+          });
+        }
+        return false;
+      }
+
+      let options = {
+        hideClose: true,
+        popupIconURL: icon || DEFAULT_EXTENSION_ICON,
+        popupIconClass: icon ? "" : "addon-warning-icon",
+        persistent: true,
+        eventCallback,
+        removeOnDismissal: true,
+        popupOptions: {
+          position: "bottomright topright",
+        },
+      };
+      // The prompt/notification machinery has a special affordance wherein
+      // certain subsets of the header string can be designated "names", and
+      // referenced symbolically as "<>" and "{}" to receive special formatting.
+      // That code assumes that the existence of |name| and |secondName| in the
+      // options object imply the presence of "<>" and "{}" (respectively) in
+      // in the string.
+      //
+      // At present, WebExtensions use this affordance while SitePermission
+      // add-ons don't, so we need to conditionally set the |name| field.
+      //
+      // NB: This could potentially be cleaned up, see bug 1799710.
+      if (strings.header.includes("<>")) {
+        options.name = strings.addonName;
+      }
+
+      let action = {
+        label: strings.acceptText,
+        accessKey: strings.acceptKey,
+        callback: () => {
+          resolve(true);
+        },
+      };
+      let secondaryActions = [
+        {
+          label: strings.cancelText,
+          accessKey: strings.cancelKey,
+          callback: () => {
+            resolve(false);
+          },
+        },
+      ];
+
+      window.PopupNotifications.show(
+        browser,
+        "addon-webext-permissions",
+        strings.header,
+        browser.ownerGlobal.gUnifiedExtensions.getPopupAnchorID(
+          browser,
+          window
+        ),
+        action,
+        secondaryActions,
+        options
+      );
+    });
+
+    this.pendingNotifications.set(browser, promise);
+    promise.finally(() => this.pendingNotifications.delete(browser));
+    return promise;
+  },
+
+  showDefaultSearchPrompt(target, strings, icon) {
+    return new Promise(resolve => {
+      let options = {
+        hideClose: true,
+        popupIconURL: icon || DEFAULT_EXTENSION_ICON,
+        persistent: true,
+        removeOnDismissal: true,
+        eventCallback(topic) {
+          if (topic == "removed") {
+            resolve(false);
+          }
+        },
+        name: strings.addonName,
+      };
+
+      let action = {
+        label: strings.acceptText,
+        accessKey: strings.acceptKey,
+        callback: () => {
+          resolve(true);
+        },
+      };
+      let secondaryActions = [
+        {
+          label: strings.cancelText,
+          accessKey: strings.cancelKey,
+          callback: () => {
+            resolve(false);
+          },
+        },
+      ];
+
+      let { browser, window } = getTabBrowser(target);
+
+      window.PopupNotifications.show(
+        browser,
+        "addon-webext-defaultsearch",
+        strings.text,
+        "addons-notification-icon",
+        action,
+        secondaryActions,
+        options
+      );
+    });
+  },
+
+  async showInstallNotification(target, addon) {
+    let { window } = getTabBrowser(target);
+
+    const message = await lazy.l10n.formatValue("addon-post-install-message", {
+      addonName: "<>",
+    });
+    const permissionName = "internal:privateBrowsingAllowed";
+    const { permissions } = await lazy.ExtensionPermissions.get(addon.id);
+    const hasIncognito = permissions.includes(permissionName);
+
+    return new Promise(resolve => {
+      // Show or hide private permission ui based on the pref.
+      function setCheckbox(win) {
+        let checkbox = win.document.getElementById("addon-incognito-checkbox");
+        checkbox.checked = hasIncognito;
+        checkbox.hidden = !(
+          addon.permissions &
+          lazy.AddonManager.PERM_CAN_CHANGE_PRIVATEBROWSING_ACCESS
+        );
+      }
+
+      async function actionResolve(win) {
+        let checkbox = win.document.getElementById("addon-incognito-checkbox");
+
+        if (checkbox.checked == hasIncognito) {
+          resolve();
+          return;
+        }
+
+        let incognitoPermission = {
+          permissions: [permissionName],
+          origins: [],
+        };
+
+        // The checkbox has been changed at this point, otherwise we would
+        // have exited early above.
+        if (checkbox.checked) {
+          await lazy.ExtensionPermissions.add(addon.id, incognitoPermission);
+        } else if (hasIncognito) {
+          await lazy.ExtensionPermissions.remove(addon.id, incognitoPermission);
+        }
+        // Reload the extension if it is already enabled.  This ensures any change
+        // on the private browsing permission is properly handled.
+        if (addon.isActive) {
+          await addon.reload();
+        }
+
+        resolve();
+      }
+
+      let action = {
+        callback: actionResolve,
+      };
+
+      let icon = addon.isWebExtension
+        ? lazy.AddonManager.getPreferredIconURL(addon, 32, window) ||
+          DEFAULT_EXTENSION_ICON
+        : "chrome://browser/skin/addons/addon-install-installed.svg";
+      let options = {
+        name: addon.name,
+        message,
+        popupIconURL: icon,
+        onRefresh: setCheckbox,
+        onDismissed: win => {
+          lazy.AppMenuNotifications.removeNotification("addon-installed");
+          actionResolve(win);
+        },
+      };
+      lazy.AppMenuNotifications.showNotification(
+        "addon-installed",
+        action,
+        null,
+        options
+      );
+    });
+  },
+
+  async showQuarantineConfirmation(browser, policy) {
+    let [title, line1, line2, allow, deny] = await lazy.l10n.formatMessages([
+      {
+        id: "webext-quarantine-confirmation-title",
+        args: { addonName: "<>" },
+      },
+      "webext-quarantine-confirmation-line-1",
+      "webext-quarantine-confirmation-line-2",
+      "webext-quarantine-confirmation-allow",
+      "webext-quarantine-confirmation-deny",
+    ]);
+
+    let attr = (msg, name) => msg.attributes.find(a => a.name === name)?.value;
+
+    let strings = {
+      addonName: policy.name,
+      header: title.value,
+      text: line1.value + "\n\n" + line2.value,
+      msgs: [],
+      acceptText: attr(allow, "label"),
+      acceptKey: attr(allow, "accesskey"),
+      cancelText: attr(deny, "label"),
+      cancelKey: attr(deny, "accesskey"),
+    };
+
+    let icon = policy.extension?.getPreferredIcon(32);
+
+    if (await ExtensionsUI.showPermissionsPrompt(browser, strings, icon)) {
+      lazy.QuarantinedDomains.setUserAllowedAddonIdPref(policy.id, true);
+    }
+  },
+
+  // Populate extension toolbar popup menu with origin controls.
+  originControlsMenu(popup, extensionId) {
+    let policy = WebExtensionPolicy.getByID(extensionId);
+
+    let win = popup.ownerGlobal;
+    let doc = popup.ownerDocument;
+    let tab = win.gBrowser.selectedTab;
+    let uri = tab.linkedBrowser?.currentURI;
+    let state = lazy.OriginControls.getState(policy, tab);
+
+    let headerItem = doc.createXULElement("menuitem");
+    headerItem.setAttribute("disabled", true);
+    let items = [headerItem];
+
+    // MV2 normally don't have controls, but we show the quarantined state.
+    if (!policy?.extension.originControls && !state.quarantined) {
+      return;
+    }
+
+    if (state.noAccess) {
+      doc.l10n.setAttributes(headerItem, "origin-controls-no-access");
+    } else {
+      doc.l10n.setAttributes(headerItem, "origin-controls-options");
+    }
+
+    if (state.quarantined) {
+      doc.l10n.setAttributes(headerItem, "origin-controls-quarantined-status");
+
+      let allowQuarantined = doc.createXULElement("menuitem");
+      doc.l10n.setAttributes(
+        allowQuarantined,
+        "origin-controls-quarantined-allow"
+      );
+      allowQuarantined.addEventListener("command", () => {
+        this.showQuarantineConfirmation(tab.linkedBrowser, policy);
+      });
+      items.push(allowQuarantined);
+    }
+
+    if (state.allDomains) {
+      let allDomains = doc.createXULElement("menuitem");
+      allDomains.setAttribute("type", "radio");
+      allDomains.setAttribute("checked", state.hasAccess);
+      doc.l10n.setAttributes(allDomains, "origin-controls-option-all-domains");
+      items.push(allDomains);
+    }
+
+    if (state.whenClicked) {
+      let whenClicked = doc.createXULElement("menuitem");
+      whenClicked.setAttribute("type", "radio");
+      whenClicked.setAttribute("checked", !state.hasAccess);
+      doc.l10n.setAttributes(
+        whenClicked,
+        "origin-controls-option-when-clicked"
+      );
+      whenClicked.addEventListener("command", async () => {
+        await lazy.OriginControls.setWhenClicked(policy, uri);
+        win.gUnifiedExtensions.updateAttention();
+      });
+      items.push(whenClicked);
+    }
+
+    if (state.alwaysOn) {
+      let alwaysOn = doc.createXULElement("menuitem");
+      alwaysOn.setAttribute("type", "radio");
+      alwaysOn.setAttribute("checked", state.hasAccess);
+      doc.l10n.setAttributes(alwaysOn, "origin-controls-option-always-on", {
+        domain: uri.host,
+      });
+      alwaysOn.addEventListener("command", async () => {
+        await lazy.OriginControls.setAlwaysOn(policy, uri);
+        win.gUnifiedExtensions.updateAttention();
+      });
+      items.push(alwaysOn);
+    }
+
+    items.push(doc.createXULElement("menuseparator"));
+
+    // Insert all items before Pin to toolbar OR Manage Extension, but after
+    // any extension's menu items.
+    let manageItem =
+      popup.querySelector(".customize-context-manageExtension") ||
+      popup.querySelector(".unified-extensions-context-menu-pin-to-toolbar");
+    items.forEach(item => item && popup.insertBefore(item, manageItem));
+
+    let cleanup = e => {
+      if (e.target === popup) {
+        items.forEach(item => item?.remove());
+        popup.removeEventListener("popuphidden", cleanup);
+      }
+    };
+    popup.addEventListener("popuphidden", cleanup);
+  },
+};
+
+EventEmitter.decorate(ExtensionsUI);
diff --git a/browser/modules/FaviconLoader.sys.mjs b/browser/modules/FaviconLoader.sys.mjs
new file mode 100644
index 0000000000..5012ee2c8c
--- /dev/null
+++ b/browser/modules/FaviconLoader.sys.mjs
@@ -0,0 +1,707 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs",
+});
+
+const STREAM_SEGMENT_SIZE = 4096;
+const PR_UINT32_MAX = 0xffffffff;
+
+const BinaryInputStream = Components.Constructor(
+  "@mozilla.org/binaryinputstream;1",
+  "nsIBinaryInputStream",
+  "setInputStream"
+);
+const StorageStream = Components.Constructor(
+  "@mozilla.org/storagestream;1",
+  "nsIStorageStream",
+  "init"
+);
+const BufferedOutputStream = Components.Constructor(
+  "@mozilla.org/network/buffered-output-stream;1",
+  "nsIBufferedOutputStream",
+  "init"
+);
+
+const SIZES_TELEMETRY_ENUM = {
+  NO_SIZES: 0,
+  ANY: 1,
+  DIMENSION: 2,
+  INVALID: 3,
+};
+
+const FAVICON_PARSING_TIMEOUT = 100;
+const FAVICON_RICH_ICON_MIN_WIDTH = 96;
+const PREFERRED_WIDTH = 16;
+
+// URL schemes that we don't want to load and convert to data URLs.
+const LOCAL_FAVICON_SCHEMES = ["chrome", "about", "resource", "data"];
+
+const MAX_FAVICON_EXPIRATION = 7 * 24 * 60 * 60 * 1000;
+const MAX_ICON_SIZE = 2048;
+
+const TYPE_ICO = "image/x-icon";
+const TYPE_SVG = "image/svg+xml";
+
+function promiseBlobAsDataURL(blob) {
+  return new Promise((resolve, reject) => {
+    let reader = new FileReader();
+    reader.addEventListener("load", () => resolve(reader.result));
+    reader.addEventListener("error", reject);
+    reader.readAsDataURL(blob);
+  });
+}
+
+function promiseBlobAsOctets(blob) {
+  return new Promise((resolve, reject) => {
+    let reader = new FileReader();
+    reader.addEventListener("load", () => {
+      resolve(Array.from(reader.result).map(c => c.charCodeAt(0)));
+    });
+    reader.addEventListener("error", reject);
+    reader.readAsBinaryString(blob);
+  });
+}
+
+function promiseImage(stream, type) {
+  return new Promise((resolve, reject) => {
+    let imgTools = Cc["@mozilla.org/image/tools;1"].getService(Ci.imgITools);
+
+    imgTools.decodeImageAsync(
+      stream,
+      type,
+      (image, result) => {
+        if (!Components.isSuccessCode(result)) {
+          reject();
+          return;
+        }
+
+        resolve(image);
+      },
+      Services.tm.currentThread
+    );
+  });
+}
+
+class FaviconLoad {
+  constructor(iconInfo) {
+    this.icon = iconInfo;
+
+    let securityFlags;
+    if (iconInfo.node.crossOrigin === "anonymous") {
+      securityFlags = Ci.nsILoadInfo.SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT;
+    } else if (iconInfo.node.crossOrigin === "use-credentials") {
+      securityFlags =
+        Ci.nsILoadInfo.SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT |
+        Ci.nsILoadInfo.SEC_COOKIES_INCLUDE;
+    } else {
+      securityFlags =
+        Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT;
+    }
+
+    this.channel = Services.io.newChannelFromURI(
+      iconInfo.iconUri,
+      iconInfo.node,
+      iconInfo.node.nodePrincipal,
+      iconInfo.node.nodePrincipal,
+      securityFlags |
+        Ci.nsILoadInfo.SEC_ALLOW_CHROME |
+        Ci.nsILoadInfo.SEC_DISALLOW_SCRIPT,
+      Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON
+    );
+
+    if (this.channel instanceof Ci.nsIHttpChannel) {
+      this.channel.QueryInterface(Ci.nsIHttpChannel);
+      let referrerInfo = Cc["@mozilla.org/referrer-info;1"].createInstance(
+        Ci.nsIReferrerInfo
+      );
+      // Sometimes node is a document and sometimes it is an element. We need
+      // to set the referrer info correctly either way.
+      if (iconInfo.node.nodeType == iconInfo.node.DOCUMENT_NODE) {
+        referrerInfo.initWithDocument(iconInfo.node);
+      } else {
+        referrerInfo.initWithElement(iconInfo.node);
+      }
+      this.channel.referrerInfo = referrerInfo;
+    }
+    this.channel.loadFlags |=
+      Ci.nsIRequest.LOAD_BACKGROUND |
+      Ci.nsIRequest.VALIDATE_NEVER |
+      Ci.nsIRequest.LOAD_FROM_CACHE;
+    // Sometimes node is a document and sometimes it is an element. This is
+    // the easiest single way to get to the load group in both those cases.
+    this.channel.loadGroup =
+      iconInfo.node.ownerGlobal.document.documentLoadGroup;
+    this.channel.notificationCallbacks = this;
+
+    if (this.channel instanceof Ci.nsIHttpChannelInternal) {
+      this.channel.blockAuthPrompt = true;
+    }
+
+    if (
+      Services.prefs.getBoolPref("network.http.tailing.enabled", true) &&
+      this.channel instanceof Ci.nsIClassOfService
+    ) {
+      this.channel.addClassFlags(
+        Ci.nsIClassOfService.Tail | Ci.nsIClassOfService.Throttleable
+      );
+    }
+  }
+
+  load() {
+    this._deferred = Promise.withResolvers();
+
+    // Clear the references when we succeed or fail.
+    let cleanup = () => {
+      this.channel = null;
+      this.dataBuffer = null;
+      this.stream = null;
+    };
+    this._deferred.promise.then(cleanup, cleanup);
+
+    this.dataBuffer = new StorageStream(STREAM_SEGMENT_SIZE, PR_UINT32_MAX);
+
+    // storage streams do not implement writeFrom so wrap it with a buffered stream.
+    this.stream = new BufferedOutputStream(
+      this.dataBuffer.getOutputStream(0),
+      STREAM_SEGMENT_SIZE * 2
+    );
+
+    try {
+      this.channel.asyncOpen(this);
+    } catch (e) {
+      this._deferred.reject(e);
+    }
+
+    return this._deferred.promise;
+  }
+
+  cancel() {
+    if (!this.channel) {
+      return;
+    }
+
+    this.channel.cancel(Cr.NS_BINDING_ABORTED);
+  }
+
+  onStartRequest(request) {}
+
+  onDataAvailable(request, inputStream, offset, count) {
+    this.stream.writeFrom(inputStream, count);
+  }
+
+  asyncOnChannelRedirect(oldChannel, newChannel, flags, callback) {
+    if (oldChannel == this.channel) {
+      this.channel = newChannel;
+    }
+
+    callback.onRedirectVerifyCallback(Cr.NS_OK);
+  }
+
+  async onStopRequest(request, statusCode) {
+    if (request != this.channel) {
+      // Indicates that a redirect has occurred. We don't care about the result
+      // of the original channel.
+      return;
+    }
+
+    this.stream.close();
+    this.stream = null;
+
+    if (!Components.isSuccessCode(statusCode)) {
+      if (statusCode == Cr.NS_BINDING_ABORTED) {
+        this._deferred.reject(
+          Components.Exception(
+            `Favicon load from ${this.icon.iconUri.spec} was cancelled.`,
+            statusCode
+          )
+        );
+      } else {
+        this._deferred.reject(
+          Components.Exception(
+            `Favicon at "${this.icon.iconUri.spec}" failed to load.`,
+            statusCode
+          )
+        );
+      }
+      return;
+    }
+
+    if (this.channel instanceof Ci.nsIHttpChannel) {
+      if (!this.channel.requestSucceeded) {
+        this._deferred.reject(
+          Components.Exception(
+            `Favicon at "${this.icon.iconUri.spec}" failed to load: ${this.channel.responseStatusText}.`,
+            { data: { httpStatus: this.channel.responseStatus } }
+          )
+        );
+        return;
+      }
+    }
+
+    // By default don't store icons added after "pageshow".
+    let canStoreIcon = this.icon.beforePageShow;
+    if (canStoreIcon) {
+      // Don't store icons responding with Cache-Control: no-store, but always
+      // allow root domain icons.
+      try {
+        if (
+          this.icon.iconUri.filePath != "/favicon.ico" &&
+          this.channel instanceof Ci.nsIHttpChannel &&
+          this.channel.isNoStoreResponse()
+        ) {
+          canStoreIcon = false;
+        }
+      } catch (ex) {
+        if (ex.result != Cr.NS_ERROR_NOT_AVAILABLE) {
+          throw ex;
+        }
+      }
+    }
+
+    // Attempt to get an expiration time from the cache.  If this fails, we'll
+    // use this default.
+    let expiration = Date.now() + MAX_FAVICON_EXPIRATION;
+
+    // This stuff isn't available after onStopRequest returns (so don't start
+    // any async operations before this!).
+    if (this.channel instanceof Ci.nsICacheInfoChannel) {
+      try {
+        expiration = Math.min(
+          this.channel.cacheTokenExpirationTime * 1000,
+          expiration
+        );
+      } catch (e) {
+        // Ignore failures to get the expiration time.
+      }
+    }
+
+    try {
+      let stream = new BinaryInputStream(this.dataBuffer.newInputStream(0));
+      let buffer = new ArrayBuffer(this.dataBuffer.length);
+      stream.readArrayBuffer(buffer.byteLength, buffer);
+
+      let type = this.channel.contentType;
+      let blob = new Blob([buffer], { type });
+
+      if (type != "image/svg+xml") {
+        let octets = await promiseBlobAsOctets(blob);
+        let sniffer = Cc["@mozilla.org/image/loader;1"].createInstance(
+          Ci.nsIContentSniffer
+        );
+        type = sniffer.getMIMETypeFromContent(
+          this.channel,
+          octets,
+          octets.length
+        );
+
+        if (!type) {
+          throw Components.Exception(
+            `Favicon at "${this.icon.iconUri.spec}" did not match a known mimetype.`,
+            Cr.NS_ERROR_FAILURE
+          );
+        }
+
+        blob = blob.slice(0, blob.size, type);
+
+        let image;
+        try {
+          image = await promiseImage(this.dataBuffer.newInputStream(0), type);
+        } catch (e) {
+          throw Components.Exception(
+            `Favicon at "${this.icon.iconUri.spec}" could not be decoded.`,
+            Cr.NS_ERROR_FAILURE
+          );
+        }
+
+        if (image.width > MAX_ICON_SIZE || image.height > MAX_ICON_SIZE) {
+          throw Components.Exception(
+            `Favicon at "${this.icon.iconUri.spec}" is too large.`,
+            Cr.NS_ERROR_FAILURE
+          );
+        }
+      }
+
+      let dataURL = await promiseBlobAsDataURL(blob);
+
+      this._deferred.resolve({
+        expiration,
+        dataURL,
+        canStoreIcon,
+      });
+    } catch (e) {
+      this._deferred.reject(e);
+    }
+  }
+
+  getInterface(iid) {
+    if (iid.equals(Ci.nsIChannelEventSink)) {
+      return this;
+    }
+    throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+  }
+}
+
+/*
+ * Extract the icon width from the size attribute. It also sends the telemetry
+ * about the size type and size dimension info.
+ *
+ * @param {Array} aSizes An array of strings about size.
+ * @return {Number} A width of the icon in pixel.
+ */
+function extractIconSize(aSizes) {
+  let width = -1;
+  let sizesType;
+  const re = /^([1-9][0-9]*)x[1-9][0-9]*$/i;
+
+  if (aSizes.length) {
+    for (let size of aSizes) {
+      if (size.toLowerCase() == "any") {
+        sizesType = SIZES_TELEMETRY_ENUM.ANY;
+        break;
+      } else {
+        let values = re.exec(size);
+        if (values && values.length > 1) {
+          sizesType = SIZES_TELEMETRY_ENUM.DIMENSION;
+          width = parseInt(values[1]);
+          break;
+        } else {
+          sizesType = SIZES_TELEMETRY_ENUM.INVALID;
+          break;
+        }
+      }
+    }
+  } else {
+    sizesType = SIZES_TELEMETRY_ENUM.NO_SIZES;
+  }
+
+  // Telemetry probes for measuring the sizes attribute
+  // usage and available dimensions.
+  Services.telemetry
+    .getHistogramById("LINK_ICON_SIZES_ATTR_USAGE")
+    .add(sizesType);
+  if (width > 0) {
+    Services.telemetry
+      .getHistogramById("LINK_ICON_SIZES_ATTR_DIMENSION")
+      .add(width);
+  }
+
+  return width;
+}
+
+/*
+ * Get link icon URI from a link dom node.
+ *
+ * @param {DOMNode} aLink A link dom node.
+ * @return {nsIURI} A uri of the icon.
+ */
+function getLinkIconURI(aLink) {
+  let targetDoc = aLink.ownerDocument;
+  let uri = Services.io.newURI(aLink.href, targetDoc.characterSet);
+  try {
+    uri = uri.mutate().setUserPass("").finalize();
+  } catch (e) {
+    // some URIs are immutable
+  }
+  return uri;
+}
+
+/**
+ * Guess a type for an icon based on its declared type or file extension.
+ */
+function guessType(icon) {
+  // No type with no icon
+  if (!icon) {
+    return "";
+  }
+
+  // Use the file extension to guess at a type we're interested in
+  if (!icon.type) {
+    let extension = icon.iconUri.filePath.split(".").pop();
+    switch (extension) {
+      case "ico":
+        return TYPE_ICO;
+      case "svg":
+        return TYPE_SVG;
+    }
+  }
+
+  // Fuzzily prefer the type or fall back to the declared type
+  return icon.type == "image/vnd.microsoft.icon" ? TYPE_ICO : icon.type || "";
+}
+
+/*
+ * Selects the best rich icon and tab icon from a list of IconInfo objects.
+ *
+ * @param {Array} iconInfos A list of IconInfo objects.
+ * @param {integer} preferredWidth The preferred width for tab icons.
+ */
+function selectIcons(iconInfos, preferredWidth) {
+  if (!iconInfos.length) {
+    return {
+      richIcon: null,
+      tabIcon: null,
+    };
+  }
+
+  let preferredIcon;
+  let bestSizedIcon;
+  // Other links with the "icon" tag are the default icons
+  let defaultIcon;
+  // Rich icons are either apple-touch or fluid icons, or the ones of the
+  // dimension 96x96 or greater
+  let largestRichIcon;
+
+  for (let icon of iconInfos) {
+    if (!icon.isRichIcon) {
+      // First check for svg. If it's not available check for an icon with a
+      // size adapt to the current resolution. If both are not available, prefer
+      // ico files. When multiple icons are in the same set, the latest wins.
+      if (guessType(icon) == TYPE_SVG) {
+        preferredIcon = icon;
+      } else if (
+        icon.width == preferredWidth &&
+        guessType(preferredIcon) != TYPE_SVG
+      ) {
+        preferredIcon = icon;
+      } else if (
+        guessType(icon) == TYPE_ICO &&
+        (!preferredIcon || guessType(preferredIcon) == TYPE_ICO)
+      ) {
+        preferredIcon = icon;
+      }
+
+      // Check for an icon larger yet closest to preferredWidth, that can be
+      // downscaled efficiently.
+      if (
+        icon.width >= preferredWidth &&
+        (!bestSizedIcon || bestSizedIcon.width >= icon.width)
+      ) {
+        bestSizedIcon = icon;
+      }
+    }
+
+    // Note that some sites use hi-res icons without specifying them as
+    // apple-touch or fluid icons.
+    if (icon.isRichIcon || icon.width >= FAVICON_RICH_ICON_MIN_WIDTH) {
+      if (!largestRichIcon || largestRichIcon.width < icon.width) {
+        largestRichIcon = icon;
+      }
+    } else {
+      defaultIcon = icon;
+    }
+  }
+
+  // Now set the favicons for the page in the following order:
+  // 1. Set the best rich icon if any.
+  // 2. Set the preferred one if any, otherwise check if there's a better
+  //    sized fit.
+  // This order allows smaller icon frames to eventually override rich icon
+  // frames.
+
+  let tabIcon = null;
+  if (preferredIcon) {
+    tabIcon = preferredIcon;
+  } else if (bestSizedIcon) {
+    tabIcon = bestSizedIcon;
+  } else if (defaultIcon) {
+    tabIcon = defaultIcon;
+  }
+
+  return {
+    richIcon: largestRichIcon,
+    tabIcon,
+  };
+}
+
+class IconLoader {
+  constructor(actor) {
+    this.actor = actor;
+  }
+
+  async load(iconInfo) {
+    if (this._loader) {
+      this._loader.cancel();
+    }
+
+    if (LOCAL_FAVICON_SCHEMES.includes(iconInfo.iconUri.scheme)) {
+      // We need to do a manual security check because the channel won't do
+      // it for us.
+      try {
+        Services.scriptSecurityManager.checkLoadURIWithPrincipal(
+          iconInfo.node.nodePrincipal,
+          iconInfo.iconUri,
+          Services.scriptSecurityManager.ALLOW_CHROME
+        );
+      } catch (ex) {
+        return;
+      }
+      this.actor.sendAsyncMessage("Link:SetIcon", {
+        pageURL: iconInfo.pageUri.spec,
+        originalURL: iconInfo.iconUri.spec,
+        canUseForTab: !iconInfo.isRichIcon,
+        expiration: undefined,
+        iconURL: iconInfo.iconUri.spec,
+        canStoreIcon: iconInfo.beforePageShow,
+        beforePageShow: iconInfo.beforePageShow,
+      });
+      return;
+    }
+
+    // Let the main process that a tab icon is possibly coming.
+    this.actor.sendAsyncMessage("Link:LoadingIcon", {
+      originalURL: iconInfo.iconUri.spec,
+      canUseForTab: !iconInfo.isRichIcon,
+    });
+
+    try {
+      this._loader = new FaviconLoad(iconInfo);
+      let { dataURL, expiration, canStoreIcon } = await this._loader.load();
+
+      this.actor.sendAsyncMessage("Link:SetIcon", {
+        pageURL: iconInfo.pageUri.spec,
+        originalURL: iconInfo.iconUri.spec,
+        canUseForTab: !iconInfo.isRichIcon,
+        expiration,
+        iconURL: dataURL,
+        canStoreIcon,
+        beforePageShow: iconInfo.beforePageShow,
+      });
+    } catch (e) {
+      if (e.result != Cr.NS_BINDING_ABORTED) {
+        if (typeof e.data?.wrappedJSObject?.httpStatus !== "number") {
+          console.error(e);
+        }
+
+        // Used mainly for tests currently.
+        this.actor.sendAsyncMessage("Link:SetFailedIcon", {
+          originalURL: iconInfo.iconUri.spec,
+          canUseForTab: !iconInfo.isRichIcon,
+        });
+      }
+    } finally {
+      this._loader = null;
+    }
+  }
+
+  cancel() {
+    if (!this._loader) {
+      return;
+    }
+
+    this._loader.cancel();
+    this._loader = null;
+  }
+}
+
+export class FaviconLoader {
+  constructor(actor) {
+    this.actor = actor;
+    this.iconInfos = [];
+
+    // Icons added after onPageShow() are likely added by modifying <link> tags
+    // through javascript; we want to avoid storing those permanently because
+    // they are probably used to show badges, and many of them could be
+    // randomly generated. This boolean can be used to track that case.
+    this.beforePageShow = true;
+
+    // For every page we attempt to find a rich icon and a tab icon. These
+    // objects take care of the load process for each.
+    this.richIconLoader = new IconLoader(actor);
+    this.tabIconLoader = new IconLoader(actor);
+
+    this.iconTask = new lazy.DeferredTask(
+      () => this.loadIcons(),
+      FAVICON_PARSING_TIMEOUT
+    );
+  }
+
+  loadIcons() {
+    // If the page is unloaded immediately after the DeferredTask's timer fires
+    // we can still attempt to load icons, which will fail since the content
+    // window is no longer available. Checking if iconInfos has been cleared
+    // allows us to bail out early in this case.
+    if (!this.iconInfos.length) {
+      return;
+    }
+
+    let preferredWidth =
+      PREFERRED_WIDTH * Math.ceil(this.actor.contentWindow.devicePixelRatio);
+    let { richIcon, tabIcon } = selectIcons(this.iconInfos, preferredWidth);
+    this.iconInfos = [];
+
+    if (richIcon) {
+      this.richIconLoader.load(richIcon);
+    }
+
+    if (tabIcon) {
+      this.tabIconLoader.load(tabIcon);
+    }
+  }
+
+  addIconFromLink(aLink, aIsRichIcon) {
+    let iconInfo = makeFaviconFromLink(aLink, aIsRichIcon);
+    if (iconInfo) {
+      iconInfo.beforePageShow = this.beforePageShow;
+      this.iconInfos.push(iconInfo);
+      this.iconTask.arm();
+      return true;
+    }
+    return false;
+  }
+
+  addDefaultIcon(pageUri) {
+    // Currently ImageDocuments will just load the default favicon, see bug
+    // 403651 for discussion.
+    this.iconInfos.push({
+      pageUri,
+      iconUri: pageUri.mutate().setPathQueryRef("/favicon.ico").finalize(),
+      width: -1,
+      isRichIcon: false,
+      type: TYPE_ICO,
+      node: this.actor.document,
+      beforePageShow: this.beforePageShow,
+    });
+    this.iconTask.arm();
+  }
+
+  onPageShow() {
+    // We're likely done with icon parsing so load the pending icons now.
+    if (this.iconTask.isArmed) {
+      this.iconTask.disarm();
+      this.loadIcons();
+    }
+    this.beforePageShow = false;
+  }
+
+  onPageHide() {
+    this.richIconLoader.cancel();
+    this.tabIconLoader.cancel();
+
+    this.iconTask.disarm();
+    this.iconInfos = [];
+  }
+}
+
+function makeFaviconFromLink(aLink, aIsRichIcon) {
+  let iconUri = getLinkIconURI(aLink);
+  if (!iconUri) {
+    return null;
+  }
+
+  // Extract the size type and width.
+  let width = extractIconSize(aLink.sizes);
+
+  return {
+    pageUri: aLink.ownerDocument.documentURIObject,
+    iconUri,
+    width,
+    isRichIcon: aIsRichIcon,
+    type: aLink.type,
+    node: aLink,
+  };
+}
diff --git a/browser/modules/HomePage.sys.mjs b/browser/modules/HomePage.sys.mjs
new file mode 100644
index 0000000000..f8f27d9bd9
--- /dev/null
+++ b/browser/modules/HomePage.sys.mjs
@@ -0,0 +1,355 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  CustomizableUI: "resource:///modules/CustomizableUI.sys.mjs",
+  ExtensionParent: "resource://gre/modules/ExtensionParent.sys.mjs",
+  ExtensionPreferencesManager:
+    "resource://gre/modules/ExtensionPreferencesManager.sys.mjs",
+  IgnoreLists: "resource://gre/modules/IgnoreLists.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+const kPrefName = "browser.startup.homepage";
+const kDefaultHomePage = "about:home";
+const kExtensionControllerPref =
+  "browser.startup.homepage_override.extensionControlled";
+const kHomePageIgnoreListId = "homepage-urls";
+const kWidgetId = "home-button";
+const kWidgetRemovedPref = "browser.engagement.home-button.has-removed";
+
+function getHomepagePref(useDefault) {
+  let homePage;
+  let prefs = Services.prefs;
+  if (useDefault) {
+    prefs = prefs.getDefaultBranch(null);
+  }
+  try {
+    // Historically, this was a localizable pref, but default Firefox builds
+    // don't use this.
+    // Distributions and local customizations might still use this, so let's
+    // keep it.
+    homePage = prefs.getComplexValue(kPrefName, Ci.nsIPrefLocalizedString).data;
+  } catch (ex) {}
+
+  if (!homePage) {
+    homePage = prefs.getStringPref(kPrefName);
+  }
+
+  // Apparently at some point users ended up with blank home pages somehow.
+  // If that happens, reset the pref and read it again.
+  if (!homePage && !useDefault) {
+    Services.prefs.clearUserPref(kPrefName);
+    homePage = getHomepagePref(true);
+  }
+
+  return homePage;
+}
+
+/**
+ * HomePage provides tools to keep track of the current homepage, and the
+ * applications's default homepage. It includes tools to insure that certain
+ * urls are ignored. As a result, all set/get requests for the homepage
+ * preferences should be routed through here.
+ */
+export let HomePage = {
+  // This is an array of strings that should be matched against URLs to see
+  // if they should be ignored or not.
+  _ignoreList: [],
+
+  // A promise that is set when initialization starts and resolved when it
+  // completes.
+  _initializationPromise: null,
+
+  /**
+   * Used to initialise the ignore lists. This may be called later than
+   * the first call to get or set, which may cause a used to get an ignored
+   * homepage, but this is deemed acceptable, as we'll correct it once
+   * initialised.
+   */
+  async delayedStartup() {
+    if (this._initializationPromise) {
+      await this._initializationPromise;
+      return;
+    }
+
+    Services.telemetry.setEventRecordingEnabled("homepage", true);
+
+    // Now we have the values, listen for future updates.
+    this._ignoreListListener = this._handleIgnoreListUpdated.bind(this);
+
+    this._initializationPromise = lazy.IgnoreLists.getAndSubscribe(
+      this._ignoreListListener
+    );
+
+    this._addCustomizableUiListener();
+
+    const current = await this._initializationPromise;
+
+    await this._handleIgnoreListUpdated({ data: { current } });
+  },
+
+  /**
+   * Gets the homepage for the given window.
+   *
+   * @param {DOMWindow} [aWindow]
+   *   The window associated with the get, used to check for private browsing
+   *   mode. If not supplied, normal mode is assumed.
+   * @returns {string}
+   *   Returns the home page value, this could be a single url, or a `|`
+   *   separated list of URLs.
+   */
+  get(aWindow) {
+    let homePages = getHomepagePref();
+    if (
+      lazy.PrivateBrowsingUtils.permanentPrivateBrowsing ||
+      (aWindow && lazy.PrivateBrowsingUtils.isWindowPrivate(aWindow))
+    ) {
+      // If an extension controls the setting and does not have private
+      // browsing permission, use the default setting.
+      let extensionControlled = Services.prefs.getBoolPref(
+        kExtensionControllerPref,
+        false
+      );
+      let privateAllowed = Services.prefs.getBoolPref(
+        "browser.startup.homepage_override.privateAllowed",
+        false
+      );
+      // There is a potential on upgrade that the prefs are not set yet, so we double check
+      // for moz-extension.
+      if (
+        !privateAllowed &&
+        (extensionControlled || homePages.includes("moz-extension://"))
+      ) {
+        return this.getDefault();
+      }
+    }
+
+    if (homePages == "about:blank") {
+      homePages = "chrome://browser/content/blanktab.html";
+    }
+
+    return homePages;
+  },
+
+  /**
+   * @returns {string}
+   *   Returns the application default homepage.
+   */
+  getDefault() {
+    return getHomepagePref(true);
+  },
+
+  /**
+   * @returns {string}
+   *   Returns the original application homepage URL (not from prefs).
+   */
+  getOriginalDefault() {
+    return kDefaultHomePage;
+  },
+
+  /**
+   * @returns {boolean}
+   *   Returns true if the homepage has been changed.
+   */
+  get overridden() {
+    return Services.prefs.prefHasUserValue(kPrefName);
+  },
+
+  /**
+   * @returns {boolean}
+   *   Returns true if the homepage preference is locked.
+   */
+  get locked() {
+    return Services.prefs.prefIsLocked(kPrefName);
+  },
+
+  /**
+   * @returns {boolean}
+   *   Returns true if the current homepage is the application default.
+   */
+  get isDefault() {
+    return HomePage.get() === kDefaultHomePage;
+  },
+
+  /**
+   * Sets the homepage preference to a new page.
+   *
+   * @param {string} value
+   *   The new value to set the preference to. This could be a single url, or a
+   *   `|` separated list of URLs.
+   */
+  async set(value) {
+    await this.delayedStartup();
+
+    if (await this.shouldIgnore(value)) {
+      console.error(
+        `Ignoring homepage setting for ${value} as it is on the ignore list.`
+      );
+      Services.telemetry.recordEvent(
+        "homepage",
+        "preference",
+        "ignore",
+        "set_blocked"
+      );
+      return false;
+    }
+    Services.prefs.setStringPref(kPrefName, value);
+    this._maybeAddHomeButtonToToolbar(value);
+    return true;
+  },
+
+  /**
+   * Sets the homepage preference to a new page. This is an synchronous version
+   * that should only be used when we know the source is safe as it bypasses the
+   * ignore list, e.g. when setting directly to about:blank or a value not
+   * supplied externally.
+   *
+   * @param {string} value
+   *   The new value to set the preference to. This could be a single url, or a
+   *   `|` separated list of URLs.
+   */
+  safeSet(value) {
+    Services.prefs.setStringPref(kPrefName, value);
+  },
+
+  /**
+   * Clears the homepage preference if it is not the default. Note that for
+   * policy/locking use, the default homepage might not be about:home after this.
+   */
+  clear() {
+    Services.prefs.clearUserPref(kPrefName);
+  },
+
+  /**
+   * Resets the homepage preference to be about:home.
+   */
+  reset() {
+    Services.prefs.setStringPref(kPrefName, kDefaultHomePage);
+  },
+
+  /**
+   * Determines if a url should be ignored according to the ignore list.
+   *
+   * @param {string} url
+   *   A string that is the url or urls to be ignored.
+   * @returns {boolean}
+   *   True if the url should be ignored.
+   */
+  async shouldIgnore(url) {
+    await this.delayedStartup();
+
+    const lowerURL = url.toLowerCase();
+    return this._ignoreList.some(code => lowerURL.includes(code.toLowerCase()));
+  },
+
+  /**
+   * Handles updates of the ignore list, checking the existing preference and
+   * correcting it as necessary.
+   *
+   * @param {Object} eventData
+   *   The event data as received from RemoteSettings.
+   */
+  async _handleIgnoreListUpdated({ data: { current } }) {
+    for (const entry of current) {
+      if (entry.id == kHomePageIgnoreListId) {
+        this._ignoreList = [...entry.matches];
+      }
+    }
+
+    // Only check if we're overridden as we assume the default value is fine,
+    // or won't be changeable (e.g. enterprise policy).
+    if (this.overridden) {
+      let homePages = getHomepagePref().toLowerCase();
+      if (
+        this._ignoreList.some(code => homePages.includes(code.toLowerCase()))
+      ) {
+        if (Services.prefs.getBoolPref(kExtensionControllerPref, false)) {
+          if (Services.appinfo.inSafeMode) {
+            // Add-ons don't get started in safe mode, so just abort this.
+            // We'll get to remove them when we next start in normal mode.
+            return;
+          }
+          // getSetting does not need the module to be loaded.
+          const item = await lazy.ExtensionPreferencesManager.getSetting(
+            "homepage_override"
+          );
+          if (item && item.id) {
+            // During startup some modules may not be loaded yet, so we load
+            // the setting we need prior to removal.
+            await lazy.ExtensionParent.apiManager.asyncLoadModule(
+              "chrome_settings_overrides"
+            );
+            lazy.ExtensionPreferencesManager.removeSetting(
+              item.id,
+              "homepage_override"
+            ).catch(console.error);
+          } else {
+            // If we don't have a setting for it, we assume the pref has
+            // been incorrectly set somehow.
+            Services.prefs.clearUserPref(kExtensionControllerPref);
+            Services.prefs.clearUserPref(
+              "browser.startup.homepage_override.privateAllowed"
+            );
+          }
+        } else {
+          this.clear();
+        }
+        Services.telemetry.recordEvent(
+          "homepage",
+          "preference",
+          "ignore",
+          "saved_reset"
+        );
+      }
+    }
+  },
+
+  onWidgetRemoved(widgetId, area) {
+    if (widgetId == kWidgetId) {
+      Services.prefs.setBoolPref(kWidgetRemovedPref, true);
+      lazy.CustomizableUI.removeListener(this);
+    }
+  },
+
+  /**
+   * Add the home button to the toolbar if the user just set a custom homepage.
+   *
+   * This should only be done once, so we check HOME_BUTTON_REMOVED_PREF which
+   * gets set to true when the home button is removed from the toolbar.
+   *
+   * If the home button is already on the toolbar it won't be moved.
+   */
+  _maybeAddHomeButtonToToolbar(homePage) {
+    if (
+      homePage !== "about:home" &&
+      homePage !== "about:blank" &&
+      !Services.prefs.getBoolPref(kExtensionControllerPref, false) &&
+      !Services.prefs.getBoolPref(kWidgetRemovedPref, false) &&
+      !lazy.CustomizableUI.getWidget(kWidgetId).areaType
+    ) {
+      // Find a spot for the home button, ideally it will be in its default
+      // position beside the stop/refresh button.
+      // Work backwards from the URL bar since it can't be removed and put
+      // the button after the first non-spring we find.
+      let navbarPlacements = lazy.CustomizableUI.getWidgetIdsInArea("nav-bar");
+      let position = navbarPlacements.indexOf("urlbar-container");
+      for (let i = position - 1; i >= 0; i--) {
+        if (!navbarPlacements[i].startsWith("customizableui-special-spring")) {
+          position = i + 1;
+          break;
+        }
+      }
+      lazy.CustomizableUI.addWidgetToArea(kWidgetId, "nav-bar", position);
+    }
+  },
+
+  _addCustomizableUiListener() {
+    if (!Services.prefs.getBoolPref(kWidgetRemovedPref, false)) {
+      lazy.CustomizableUI.addListener(this);
+    }
+  },
+};
diff --git a/browser/modules/LaterRun.sys.mjs b/browser/modules/LaterRun.sys.mjs
new file mode 100644
index 0000000000..505942d617
--- /dev/null
+++ b/browser/modules/LaterRun.sys.mjs
@@ -0,0 +1,209 @@
+/* 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/. */
+
+const kEnabledPref = "browser.laterrun.enabled";
+const kPagePrefRoot = "browser.laterrun.pages.";
+// Number of sessions we've been active in
+const kSessionCountPref = "browser.laterrun.bookkeeping.sessionCount";
+// Time the profile was created at in seconds:
+const kProfileCreationTime = "browser.laterrun.bookkeeping.profileCreationTime";
+// Time the update was applied at in seconds:
+const kUpdateAppliedTime = "browser.laterrun.bookkeeping.updateAppliedTime";
+
+// After 50 sessions or 1 month since install, assume we will no longer be
+// interested in showing anything to "new" users
+const kSelfDestructSessionLimit = 50;
+const kSelfDestructHoursLimit = 31 * 24;
+
+class Page {
+  constructor({
+    pref,
+    minimumHoursSinceInstall,
+    minimumSessionCount,
+    requireBoth,
+    url,
+  }) {
+    this.pref = pref;
+    this.minimumHoursSinceInstall = minimumHoursSinceInstall || 0;
+    this.minimumSessionCount = minimumSessionCount || 1;
+    this.requireBoth = requireBoth || false;
+    this.url = url;
+  }
+
+  get hasRun() {
+    return Services.prefs.getBoolPref(this.pref + "hasRun", false);
+  }
+
+  applies(sessionInfo) {
+    if (this.hasRun) {
+      return false;
+    }
+    if (this.requireBoth) {
+      return (
+        sessionInfo.sessionCount >= this.minimumSessionCount &&
+        sessionInfo.hoursSinceInstall >= this.minimumHoursSinceInstall
+      );
+    }
+    return (
+      sessionInfo.sessionCount >= this.minimumSessionCount ||
+      sessionInfo.hoursSinceInstall >= this.minimumHoursSinceInstall
+    );
+  }
+}
+
+export let LaterRun = {
+  get ENABLE_REASON_NEW_PROFILE() {
+    return 1;
+  },
+  get ENABLE_REASON_UPDATE_APPLIED() {
+    return 2;
+  },
+
+  init(reason) {
+    if (!this.enabled) {
+      return;
+    }
+
+    if (reason == this.ENABLE_REASON_NEW_PROFILE) {
+      // If this is the first run, set the time we were installed
+      if (
+        Services.prefs.getPrefType(kProfileCreationTime) ==
+        Ci.nsIPrefBranch.PREF_INVALID
+      ) {
+        // We need to store seconds in order to fit within int prefs.
+        Services.prefs.setIntPref(
+          kProfileCreationTime,
+          Math.floor(Date.now() / 1000)
+        );
+      }
+      this.sessionCount++;
+    } else if (reason == this.ENABLE_REASON_UPDATE_APPLIED) {
+      Services.prefs.setIntPref(
+        kUpdateAppliedTime,
+        Math.floor(Services.startup.getStartupInfo().start.getTime() / 1000)
+      );
+    }
+
+    if (
+      this.hoursSinceInstall > kSelfDestructHoursLimit ||
+      this.sessionCount > kSelfDestructSessionLimit
+    ) {
+      this.selfDestruct();
+    }
+  },
+
+  // The enabled, hoursSinceInstall and sessionCount properties mirror the
+  // preferences system, and are here for convenience.
+  get enabled() {
+    return Services.prefs.getBoolPref(kEnabledPref, false);
+  },
+
+  enable(reason) {
+    if (!this.enabled) {
+      Services.prefs.setBoolPref(kEnabledPref, true);
+      this.init(reason);
+    }
+  },
+
+  get hoursSinceInstall() {
+    let installStampSec = Services.prefs.getIntPref(
+      kProfileCreationTime,
+      Date.now() / 1000
+    );
+    return Math.floor((Date.now() / 1000 - installStampSec) / 3600);
+  },
+
+  get hoursSinceUpdate() {
+    let updateStampSec = Services.prefs.getIntPref(kUpdateAppliedTime, 0);
+    return Math.floor((Date.now() / 1000 - updateStampSec) / 3600);
+  },
+
+  get sessionCount() {
+    if (this._sessionCount) {
+      return this._sessionCount;
+    }
+    return (this._sessionCount = Services.prefs.getIntPref(
+      kSessionCountPref,
+      0
+    ));
+  },
+
+  set sessionCount(val) {
+    this._sessionCount = val;
+    Services.prefs.setIntPref(kSessionCountPref, val);
+  },
+
+  // Because we don't want to keep incrementing this indefinitely for no reason,
+  // we will turn ourselves off after a set amount of time/sessions (see top of
+  // file).
+  selfDestruct() {
+    Services.prefs.setBoolPref(kEnabledPref, false);
+  },
+
+  // Create an array of Page objects based on the currently set prefs
+  readPages() {
+    // Enumerate all the pages.
+    let allPrefsForPages = Services.prefs.getChildList(kPagePrefRoot);
+    let pageDataStore = new Map();
+    for (let pref of allPrefsForPages) {
+      let [slug, prop] = pref.substring(kPagePrefRoot.length).split(".");
+      if (!pageDataStore.has(slug)) {
+        pageDataStore.set(slug, {
+          pref: pref.substring(0, pref.length - prop.length),
+        });
+      }
+      if (prop == "requireBoth" || prop == "hasRun") {
+        pageDataStore.get(slug)[prop] = Services.prefs.getBoolPref(pref, false);
+      } else if (prop == "url") {
+        pageDataStore.get(slug)[prop] = Services.prefs.getStringPref(pref, "");
+      } else {
+        pageDataStore.get(slug)[prop] = Services.prefs.getIntPref(pref, 0);
+      }
+    }
+    let rv = [];
+    for (let [, pageData] of pageDataStore) {
+      if (pageData.url) {
+        let uri = null;
+        try {
+          let urlString = Services.urlFormatter.formatURL(pageData.url.trim());
+          uri = Services.io.newURI(urlString);
+        } catch (ex) {
+          console.error(
+            "Invalid LaterRun page URL ",
+            pageData.url,
+            " ignored."
+          );
+          continue;
+        }
+        if (!uri.schemeIs("https")) {
+          console.error("Insecure LaterRun page URL ", uri.spec, " ignored.");
+        } else {
+          pageData.url = uri.spec;
+          rv.push(new Page(pageData));
+        }
+      }
+    }
+    return rv;
+  },
+
+  // Return a URL for display as a 'later run' page if its criteria are matched,
+  // or null otherwise.
+  // NB: will only return one page at a time; if multiple pages match, it's up
+  // to the preference service which one gets shown first, and the next one
+  // will be shown next startup instead.
+  getURL() {
+    if (!this.enabled) {
+      return null;
+    }
+    let pages = this.readPages();
+    let page = pages.find(p => p.applies(this));
+    if (page) {
+      Services.prefs.setBoolPref(page.pref + "hasRun", true);
+      return page.url;
+    }
+    return null;
+  },
+};
+
+LaterRun.init();
diff --git a/browser/modules/NewTabPagePreloading.sys.mjs b/browser/modules/NewTabPagePreloading.sys.mjs
new file mode 100644
index 0000000000..bf6b050195
--- /dev/null
+++ b/browser/modules/NewTabPagePreloading.sys.mjs
@@ -0,0 +1,204 @@
+/* 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/. */
+
+/*
+ * This module is in charge of preloading 'new tab' pages for use when
+ * the user opens a new tab.
+ */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
+  BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
+  E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+export let NewTabPagePreloading = {
+  // Maximum number of instances of a given page we'll preload at any time.
+  // Because we preload about:newtab for normal windows, and about:privatebrowsing
+  // for private ones, we could have 3 of each.
+  MAX_COUNT: 3,
+
+  // How many preloaded tabs we have, across all windows, for the private and non-private
+  // case:
+  browserCounts: {
+    normal: 0,
+    private: 0,
+  },
+
+  get enabled() {
+    return (
+      this.prefEnabled &&
+      this.newTabEnabled &&
+      !lazy.AboutNewTab.newTabURLOverridden
+    );
+  },
+
+  /**
+   * Create a browser in the right process type.
+   */
+  _createBrowser(win) {
+    const {
+      gBrowser,
+      gMultiProcessBrowser,
+      gFissionBrowser,
+      BROWSER_NEW_TAB_URL,
+    } = win;
+
+    let oa = lazy.E10SUtils.predictOriginAttributes({ window: win });
+
+    let remoteType = lazy.E10SUtils.getRemoteTypeForURI(
+      BROWSER_NEW_TAB_URL,
+      gMultiProcessBrowser,
+      gFissionBrowser,
+      lazy.E10SUtils.DEFAULT_REMOTE_TYPE,
+      null,
+      oa
+    );
+    let browser = gBrowser.createBrowser({
+      isPreloadBrowser: true,
+      remoteType,
+    });
+    gBrowser.preloadedBrowser = browser;
+
+    let panel = gBrowser.getPanel(browser);
+    gBrowser.tabpanels.appendChild(panel);
+
+    return browser;
+  },
+
+  /**
+   * Move the contents of a preload browser across to a different window.
+   */
+  _adoptBrowserFromOtherWindow(window) {
+    let winPrivate = lazy.PrivateBrowsingUtils.isWindowPrivate(window);
+    // Grab the least-recently-focused window with a preloaded browser:
+    let oldWin = lazy.BrowserWindowTracker.orderedWindows
+      .filter(w => {
+        return (
+          winPrivate == lazy.PrivateBrowsingUtils.isWindowPrivate(w) &&
+          w.gBrowser &&
+          w.gBrowser.preloadedBrowser
+        );
+      })
+      .pop();
+    if (!oldWin) {
+      return null;
+    }
+    // Don't call getPreloadedBrowser because it'll consume the browser:
+    let oldBrowser = oldWin.gBrowser.preloadedBrowser;
+    oldWin.gBrowser.preloadedBrowser = null;
+
+    let newBrowser = this._createBrowser(window);
+
+    oldBrowser.swapBrowsers(newBrowser);
+
+    newBrowser.permanentKey = oldBrowser.permanentKey;
+
+    oldWin.gBrowser.getPanel(oldBrowser).remove();
+    return newBrowser;
+  },
+
+  maybeCreatePreloadedBrowser(window) {
+    // If we're not enabled, have already got one, are in a popup window, or the
+    // window is minimized / occluded, don't bother creating a preload browser -
+    // there's no point.
+    if (
+      !this.enabled ||
+      window.gBrowser.preloadedBrowser ||
+      !window.toolbar.visible ||
+      window.document.hidden
+    ) {
+      return;
+    }
+
+    // Don't bother creating a preload browser if we're not in the top set of windows:
+    let windowPrivate = lazy.PrivateBrowsingUtils.isWindowPrivate(window);
+    let countKey = windowPrivate ? "private" : "normal";
+    let topWindows = lazy.BrowserWindowTracker.orderedWindows.filter(
+      w => lazy.PrivateBrowsingUtils.isWindowPrivate(w) == windowPrivate
+    );
+    if (topWindows.indexOf(window) >= this.MAX_COUNT) {
+      return;
+    }
+
+    // If we're in the top set of windows, and we already have enough preloaded
+    // tabs, don't create yet another one, just steal an existing one:
+    if (this.browserCounts[countKey] >= this.MAX_COUNT) {
+      let browser = this._adoptBrowserFromOtherWindow(window);
+      // We can potentially get null here if we couldn't actually find another
+      // browser to adopt from. This can be the case when there's a mix of
+      // private and non-private windows, for instance.
+      if (browser) {
+        return;
+      }
+    }
+
+    let browser = this._createBrowser(window);
+    browser.loadURI(Services.io.newURI(window.BROWSER_NEW_TAB_URL), {
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+    });
+    browser.docShellIsActive = false;
+    browser._urlbarFocused = true;
+
+    // Make sure the preloaded browser is loaded with desired zoom level
+    let tabURI = Services.io.newURI(window.BROWSER_NEW_TAB_URL);
+    window.FullZoom.onLocationChange(tabURI, false, browser);
+
+    this.browserCounts[countKey]++;
+  },
+
+  getPreloadedBrowser(window) {
+    if (!this.enabled) {
+      return null;
+    }
+
+    // The preloaded browser might be null.
+    let browser = window.gBrowser.preloadedBrowser;
+
+    // Consume the browser.
+    window.gBrowser.preloadedBrowser = null;
+
+    // Attach the nsIFormFillController now that we know the browser
+    // will be used. If we do that before and the preloaded browser
+    // won't be consumed until shutdown then we leak a docShell.
+    // Also, we do not need to take care of attaching nsIFormFillControllers
+    // in the case that the browser is remote, as remote browsers take
+    // care of that themselves.
+    if (browser) {
+      let countKey = lazy.PrivateBrowsingUtils.isWindowPrivate(window)
+        ? "private"
+        : "normal";
+      this.browserCounts[countKey]--;
+      browser.removeAttribute("preloadedState");
+      browser.setAttribute("autocompletepopup", "PopupAutoComplete");
+    }
+
+    return browser;
+  },
+
+  removePreloadedBrowser(window) {
+    let browser = this.getPreloadedBrowser(window);
+    if (browser) {
+      window.gBrowser.getPanel(browser).remove();
+    }
+  },
+};
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  NewTabPagePreloading,
+  "prefEnabled",
+  "browser.newtab.preload",
+  true
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  NewTabPagePreloading,
+  "newTabEnabled",
+  "browser.newtabpage.enabled",
+  true
+);
diff --git a/browser/modules/OpenInTabsUtils.sys.mjs b/browser/modules/OpenInTabsUtils.sys.mjs
new file mode 100644
index 0000000000..bea547d915
--- /dev/null
+++ b/browser/modules/OpenInTabsUtils.sys.mjs
@@ -0,0 +1,77 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineLazyGetter(lazy, "l10n", () => {
+  return new Localization(
+    ["browser/tabbrowser.ftl", "branding/brand.ftl"],
+    true
+  );
+});
+
+/**
+ * Utility functions that can be used when opening multiple tabs, that can be
+ * called without any tabbrowser instance.
+ */
+export const OpenInTabsUtils = {
+  /**
+   * Gives the user a chance to cancel loading lots of tabs at once.
+   */
+  confirmOpenInTabs(numTabsToOpen, aWindow) {
+    const WARN_ON_OPEN_PREF = "browser.tabs.warnOnOpen";
+    const MAX_OPNE_PREF = "browser.tabs.maxOpenBeforeWarn";
+    if (!Services.prefs.getBoolPref(WARN_ON_OPEN_PREF)) {
+      return true;
+    }
+    if (numTabsToOpen < Services.prefs.getIntPref(MAX_OPNE_PREF)) {
+      return true;
+    }
+
+    // default to true: if it were false, we wouldn't get this far
+    let warnOnOpen = { value: true };
+
+    const [title, message, button, checkbox] = lazy.l10n.formatMessagesSync([
+      { id: "tabbrowser-confirm-open-multiple-tabs-title" },
+      {
+        id: "tabbrowser-confirm-open-multiple-tabs-message",
+        args: { tabCount: numTabsToOpen },
+      },
+      { id: "tabbrowser-confirm-open-multiple-tabs-button" },
+      { id: "tabbrowser-confirm-open-multiple-tabs-checkbox" },
+    ]);
+
+    let buttonPressed = Services.prompt.confirmEx(
+      aWindow,
+      title.value,
+      message.value,
+      Services.prompt.BUTTON_TITLE_IS_STRING * Services.prompt.BUTTON_POS_0 +
+        Services.prompt.BUTTON_TITLE_CANCEL * Services.prompt.BUTTON_POS_1,
+      button.value,
+      null,
+      null,
+      checkbox.value,
+      warnOnOpen
+    );
+
+    let reallyOpen = buttonPressed == 0;
+    // don't set the pref unless they press OK and it's false
+    if (reallyOpen && !warnOnOpen.value) {
+      Services.prefs.setBoolPref(WARN_ON_OPEN_PREF, false);
+    }
+
+    return reallyOpen;
+  },
+
+  /*
+   * Async version of confirmOpenInTabs.
+   */
+  promiseConfirmOpenInTabs(numTabsToOpen, aWindow) {
+    return new Promise(resolve => {
+      Services.tm.dispatchToMainThread(() => {
+        resolve(this.confirmOpenInTabs(numTabsToOpen, aWindow));
+      });
+    });
+  },
+};
diff --git a/browser/modules/PageActions.sys.mjs b/browser/modules/PageActions.sys.mjs
new file mode 100644
index 0000000000..4e089f2fc7
--- /dev/null
+++ b/browser/modules/PageActions.sys.mjs
@@ -0,0 +1,1276 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AsyncShutdown: "resource://gre/modules/AsyncShutdown.sys.mjs",
+  ASRouter: "resource:///modules/asrouter/ASRouter.sys.mjs",
+  BinarySearch: "resource://gre/modules/BinarySearch.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+const ACTION_ID_BOOKMARK = "bookmark";
+const ACTION_ID_BUILT_IN_SEPARATOR = "builtInSeparator";
+const ACTION_ID_TRANSIENT_SEPARATOR = "transientSeparator";
+
+const PREF_PERSISTED_ACTIONS = "browser.pageActions.persistedActions";
+const PERSISTED_ACTIONS_CURRENT_VERSION = 1;
+
+// Escapes the given raw URL string, and returns an equivalent CSS url()
+// value for it.
+function escapeCSSURL(url) {
+  return `url("${url.replace(/[\\\s"]/g, encodeURIComponent)}")`;
+}
+
+export var PageActions = {
+  /**
+   * Initializes PageActions.
+   *
+   * @param {boolean} addShutdownBlocker
+   *   This param exists only for tests.  Normally the default value of true
+   *   must be used.
+   */
+  init(addShutdownBlocker = true) {
+    this._initBuiltInActions();
+
+    let callbacks = this._deferredAddActionCalls;
+    delete this._deferredAddActionCalls;
+
+    this._loadPersistedActions();
+
+    // Register the built-in actions, which are defined below in this file.
+    for (let options of gBuiltInActions) {
+      if (!this.actionForID(options.id)) {
+        this._registerAction(new Action(options));
+      }
+    }
+
+    // Now place them all in each window.  Instead of splitting the register and
+    // place steps, we could simply call addAction, which does both, but doing
+    // it this way means that all windows initially place their actions in the
+    // urlbar the same way -- placeAllActions -- regardless of whether they're
+    // open when this method is called or opened later.
+    for (let bpa of allBrowserPageActions()) {
+      bpa.placeAllActionsInUrlbar();
+    }
+
+    // These callbacks are deferred until init happens and all built-in actions
+    // are added.
+    while (callbacks && callbacks.length) {
+      callbacks.shift()();
+    }
+
+    if (addShutdownBlocker) {
+      // Purge removed actions from persisted state on shutdown.  The point is
+      // not to do it on Action.remove().  That way actions that are removed and
+      // re-added while the app is running will have their urlbar placement and
+      // other state remembered and restored.  This happens for upgraded and
+      // downgraded extensions, for example.
+      lazy.AsyncShutdown.profileBeforeChange.addBlocker(
+        "PageActions: purging unregistered actions from cache",
+        () => this._purgeUnregisteredPersistedActions()
+      );
+    }
+  },
+
+  _deferredAddActionCalls: [],
+
+  /**
+   * A list of all Action objects, not in any particular order.  Not live.
+   * (array of Action objects)
+   */
+  get actions() {
+    let lists = [
+      this._builtInActions,
+      this._nonBuiltInActions,
+      this._transientActions,
+    ];
+    return lists.reduce((memo, list) => memo.concat(list), []);
+  },
+
+  /**
+   * The list of Action objects that should appear in the panel for a given
+   * window, sorted in the order in which they appear.  If there are both
+   * built-in and non-built-in actions, then the list will include the separator
+   * between the two.  The list is not live.  (array of Action objects)
+   *
+   * @param  browserWindow (DOM window, required)
+   *         This window's actions will be returned.
+   * @return (array of PageAction.Action objects) The actions currently in the
+   *         given window's panel.
+   */
+  actionsInPanel(browserWindow) {
+    function filter(action) {
+      return action.shouldShowInPanel(browserWindow);
+    }
+    let actions = this._builtInActions.filter(filter);
+    let nonBuiltInActions = this._nonBuiltInActions.filter(filter);
+    if (nonBuiltInActions.length) {
+      if (actions.length) {
+        actions.push(
+          new Action({
+            id: ACTION_ID_BUILT_IN_SEPARATOR,
+            _isSeparator: true,
+          })
+        );
+      }
+      actions.push(...nonBuiltInActions);
+    }
+    let transientActions = this._transientActions.filter(filter);
+    if (transientActions.length) {
+      if (actions.length) {
+        actions.push(
+          new Action({
+            id: ACTION_ID_TRANSIENT_SEPARATOR,
+            _isSeparator: true,
+          })
+        );
+      }
+      actions.push(...transientActions);
+    }
+    return actions;
+  },
+
+  /**
+   * The list of actions currently in the urlbar, sorted in the order in which
+   * they appear.  Not live.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         This window's actions will be returned.
+   * @return (array of PageAction.Action objects) The actions currently in the
+   *         given window's urlbar.
+   */
+  actionsInUrlbar(browserWindow) {
+    // Remember that IDs in idsInUrlbar may belong to actions that aren't
+    // currently registered.
+    return this._persistedActions.idsInUrlbar.reduce((actions, id) => {
+      let action = this.actionForID(id);
+      if (action && action.shouldShowInUrlbar(browserWindow)) {
+        actions.push(action);
+      }
+      return actions;
+    }, []);
+  },
+
+  /**
+   * Gets an action.
+   *
+   * @param  id (string, required)
+   *         The ID of the action to get.
+   * @return The Action object, or null if none.
+   */
+  actionForID(id) {
+    return this._actionsByID.get(id);
+  },
+
+  /**
+   * Registers an action.
+   *
+   * Actions are registered by their IDs.  An error is thrown if an action with
+   * the given ID has already been added.  Use actionForID() before calling this
+   * method if necessary.
+   *
+   * Be sure to call remove() on the action if the lifetime of the code that
+   * owns it is shorter than the browser's -- if it lives in an extension, for
+   * example.
+   *
+   * @param  action (Action, required)
+   *         The Action object to register.
+   * @return The given Action.
+   */
+  addAction(action) {
+    if (this._deferredAddActionCalls) {
+      // init() hasn't been called yet.  Defer all additions until it's called,
+      // at which time _deferredAddActionCalls will be deleted.
+      this._deferredAddActionCalls.push(() => this.addAction(action));
+      return action;
+    }
+    this._registerAction(action);
+    for (let bpa of allBrowserPageActions()) {
+      bpa.placeAction(action);
+    }
+    return action;
+  },
+
+  _registerAction(action) {
+    if (this.actionForID(action.id)) {
+      throw new Error(`Action with ID '${action.id}' already added`);
+    }
+    this._actionsByID.set(action.id, action);
+
+    // Insert the action into the appropriate list, either _builtInActions or
+    // _nonBuiltInActions.
+
+    // Keep in mind that _insertBeforeActionID may be present but null, which
+    // means the action should be appended to the built-ins.
+    if ("__insertBeforeActionID" in action) {
+      // A "semi-built-in" action, probably an action from an extension
+      // bundled with the browser.  Right now we simply assume that no other
+      // consumers will use _insertBeforeActionID.
+      let index = !action.__insertBeforeActionID
+        ? -1
+        : this._builtInActions.findIndex(a => {
+            return a.id == action.__insertBeforeActionID;
+          });
+      if (index < 0) {
+        // Append the action (excluding transient actions).
+        index = this._builtInActions.filter(a => !a.__transient).length;
+      }
+      this._builtInActions.splice(index, 0, action);
+    } else if (action.__transient) {
+      // A transient action.
+      this._transientActions.push(action);
+    } else if (action._isBuiltIn) {
+      // A built-in action. These are mostly added on init before all other
+      // actions, one after the other. Extension actions load later and should
+      // be at the end, so just push onto the array.
+      this._builtInActions.push(action);
+    } else {
+      // A non-built-in action, like a non-bundled extension potentially.
+      // Keep this list sorted by title.
+      let index = lazy.BinarySearch.insertionIndexOf(
+        (a1, a2) => {
+          return a1.getTitle().localeCompare(a2.getTitle());
+        },
+        this._nonBuiltInActions,
+        action
+      );
+      this._nonBuiltInActions.splice(index, 0, action);
+    }
+
+    let isNew = !this._persistedActions.ids.includes(action.id);
+    if (isNew) {
+      // The action is new.  Store it in the persisted actions.
+      this._persistedActions.ids.push(action.id);
+    }
+
+    // Actions are always pinned to the urlbar, except for panel separators.
+    action._pinnedToUrlbar = !action.__isSeparator;
+    this._updateIDsPinnedToUrlbarForAction(action);
+  },
+
+  _updateIDsPinnedToUrlbarForAction(action) {
+    let index = this._persistedActions.idsInUrlbar.indexOf(action.id);
+    if (action.pinnedToUrlbar) {
+      if (index < 0) {
+        index =
+          action.id == ACTION_ID_BOOKMARK
+            ? -1
+            : this._persistedActions.idsInUrlbar.indexOf(ACTION_ID_BOOKMARK);
+        if (index < 0) {
+          index = this._persistedActions.idsInUrlbar.length;
+        }
+        this._persistedActions.idsInUrlbar.splice(index, 0, action.id);
+      }
+    } else if (index >= 0) {
+      this._persistedActions.idsInUrlbar.splice(index, 1);
+    }
+    this._storePersistedActions();
+  },
+
+  // These keep track of currently registered actions.
+  _builtInActions: [],
+  _nonBuiltInActions: [],
+  _transientActions: [],
+  _actionsByID: new Map(),
+
+  /**
+   * Call this when an action is removed.
+   *
+   * @param  action (Action object, required)
+   *         The action that was removed.
+   */
+  onActionRemoved(action) {
+    if (!this.actionForID(action.id)) {
+      // The action isn't registered (yet).  Not an error.
+      return;
+    }
+
+    this._actionsByID.delete(action.id);
+    let lists = [
+      this._builtInActions,
+      this._nonBuiltInActions,
+      this._transientActions,
+    ];
+    for (let list of lists) {
+      let index = list.findIndex(a => a.id == action.id);
+      if (index >= 0) {
+        list.splice(index, 1);
+        break;
+      }
+    }
+
+    for (let bpa of allBrowserPageActions()) {
+      bpa.removeAction(action);
+    }
+  },
+
+  /**
+   * Call this when an action's pinnedToUrlbar property changes.
+   *
+   * @param  action (Action object, required)
+   *         The action whose pinnedToUrlbar property changed.
+   */
+  onActionToggledPinnedToUrlbar(action) {
+    if (!this.actionForID(action.id)) {
+      // This may be called before the action has been added.
+      return;
+    }
+    this._updateIDsPinnedToUrlbarForAction(action);
+    for (let bpa of allBrowserPageActions()) {
+      bpa.placeActionInUrlbar(action);
+    }
+  },
+
+  // For tests.  See Bug 1413692.
+  _reset() {
+    PageActions._purgeUnregisteredPersistedActions();
+    PageActions._builtInActions = [];
+    PageActions._nonBuiltInActions = [];
+    PageActions._transientActions = [];
+    PageActions._actionsByID = new Map();
+  },
+
+  _storePersistedActions() {
+    let json = JSON.stringify(this._persistedActions);
+    Services.prefs.setStringPref(PREF_PERSISTED_ACTIONS, json);
+  },
+
+  _loadPersistedActions() {
+    let actions;
+    try {
+      let json = Services.prefs.getStringPref(PREF_PERSISTED_ACTIONS);
+      actions = this._migratePersistedActions(JSON.parse(json));
+    } catch (ex) {}
+
+    // Handle migrating to and from Proton.  We want to gracefully handle
+    // downgrades from Proton, and since Proton is controlled by a pref, we also
+    // don't want to assume that a downgrade is possible only by downgrading the
+    // app.  That makes it hard to use the normal migration approach of creating
+    // a new persisted actions version, so we handle Proton migration specially.
+    // We try-catch it separately from the earlier _migratePersistedActions call
+    // because it should not be short-circuited when the pref load or usual
+    // migration fails.
+    try {
+      actions = this._migratePersistedActionsProton(actions);
+    } catch (ex) {}
+
+    // If `actions` is still not defined, then this._persistedActions will
+    // remain its default value.
+    if (actions) {
+      this._persistedActions = actions;
+    }
+  },
+
+  _purgeUnregisteredPersistedActions() {
+    // Remove all action IDs from persisted state that do not correspond to
+    // currently registered actions.
+    for (let name of ["ids", "idsInUrlbar"]) {
+      this._persistedActions[name] = this._persistedActions[name].filter(id => {
+        return this.actionForID(id);
+      });
+    }
+    this._storePersistedActions();
+  },
+
+  _migratePersistedActions(actions) {
+    // Start with actions.version and migrate one version at a time, all the way
+    // up to the current version.
+    for (
+      let version = actions.version || 0;
+      version < PERSISTED_ACTIONS_CURRENT_VERSION;
+      version++
+    ) {
+      let methodName = `_migratePersistedActionsTo${version + 1}`;
+      actions = this[methodName](actions);
+      actions.version = version + 1;
+    }
+    return actions;
+  },
+
+  _migratePersistedActionsTo1(actions) {
+    // The `ids` object is a mapping: action ID => true.  Convert it to an array
+    // to save space in the prefs.
+    let ids = [];
+    for (let id in actions.ids) {
+      ids.push(id);
+    }
+    // Move the bookmark ID to the end of idsInUrlbar.  The bookmark action
+    // should always remain at the end of the urlbar, if present.
+    let bookmarkIndex = actions.idsInUrlbar.indexOf(ACTION_ID_BOOKMARK);
+    if (bookmarkIndex >= 0) {
+      actions.idsInUrlbar.splice(bookmarkIndex, 1);
+      actions.idsInUrlbar.push(ACTION_ID_BOOKMARK);
+    }
+    return {
+      ids,
+      idsInUrlbar: actions.idsInUrlbar,
+    };
+  },
+
+  _migratePersistedActionsProton(actions) {
+    if (actions?.idsInUrlbarPreProton) {
+      // continue with Proton
+    } else if (actions) {
+      // upgrade to Proton
+      actions.idsInUrlbarPreProton = [...(actions.idsInUrlbar || [])];
+    } else {
+      // new profile with Proton
+      actions = {
+        ids: [],
+        idsInUrlbar: [],
+        idsInUrlbarPreProton: [],
+        version: PERSISTED_ACTIONS_CURRENT_VERSION,
+      };
+    }
+    return actions;
+  },
+
+  /**
+   * Send an ASRouter trigger to possibly show messaging related to the page
+   * action that was placed in the urlbar.
+   *
+   * @param {Element} buttonNode The page action button node.
+   */
+  sendPlacedInUrlbarTrigger(buttonNode) {
+    lazy.setTimeout(async () => {
+      await lazy.ASRouter.initialized;
+      let win = buttonNode?.ownerGlobal;
+      if (!win || buttonNode.hidden) {
+        return;
+      }
+      await lazy.ASRouter.sendTriggerMessage({
+        browser: win.gBrowser.selectedBrowser,
+        id: "pageActionInUrlbar",
+        context: { pageAction: buttonNode.id },
+      });
+    }, 500);
+  },
+
+  // This keeps track of all actions, even those that are not currently
+  // registered because they have been removed, so long as
+  // _purgeUnregisteredPersistedActions has not been called.
+  _persistedActions: {
+    version: PERSISTED_ACTIONS_CURRENT_VERSION,
+    // action IDs that have ever been seen and not removed, order not important
+    ids: [],
+    // action IDs ordered by position in urlbar
+    idsInUrlbar: [],
+  },
+};
+
+/**
+ * A single page action.
+ *
+ * Each action can have both per-browser-window state and global state.
+ * Per-window state takes precedence over global state.  This is reflected in
+ * the title, tooltip, disabled, and icon properties.  Each of these properties
+ * has a getter method and setter method that takes a browser window.  Pass null
+ * to get the action's global state.  Pass a browser window to get the per-
+ * window state.  However, if you pass a window and the action has no state for
+ * that window, then the global state will be returned.
+ *
+ * `options` is a required object with the following properties.  Regarding the
+ * properties discussed in the previous paragraph, the values in `options` set
+ * global state.
+ *
+ * @param id (string, required)
+ *        The action's ID.  Treat this like the ID of a DOM node.
+ * @param title (string, optional)
+ *        The action's title. It is optional for built in actions.
+ * @param anchorIDOverride (string, optional)
+ *        Pass a string to override the node to which the action's activated-
+ *        action panel is anchored.
+ * @param disabled (bool, optional)
+ *        Pass true to cause the action to be disabled initially in all browser
+ *        windows.  False by default.
+ * @param extensionID (string, optional)
+ *        If the action lives in an extension, pass its ID.
+ * @param iconURL (string or object, optional)
+ *        The URL string of the action's icon.  Usually you want to specify an
+ *        icon in CSS, but this option is useful if that would be a pain for
+ *        some reason.  You can also pass an object that maps pixel sizes to
+ *        URLs, like { 16: url16, 32: url32 }.  The best size for the user's
+ *        screen will be used.
+ * @param isBadged (bool, optional)
+ *        If true, the toolbarbutton for this action will get a
+ *        "badged" attribute.
+ * @param onBeforePlacedInWindow (function, optional)
+ *        Called before the action is placed in the window:
+ *        onBeforePlacedInWindow(window)
+ *        * window: The window that the action will be placed in.
+ * @param onCommand (function, optional)
+ *        Called when the action is clicked, but only if it has neither a
+ *        subview nor an iframe:
+ *        onCommand(event, buttonNode)
+ *        * event: The triggering event.
+ *        * buttonNode: The button node that was clicked.
+ * @param onIframeHiding (function, optional)
+ *        Called when the action's iframe is hiding:
+ *        onIframeHiding(iframeNode, parentPanelNode)
+ *        * iframeNode: The iframe.
+ *        * parentPanelNode: The panel node in which the iframe is shown.
+ * @param onIframeHidden (function, optional)
+ *        Called when the action's iframe is hidden:
+ *        onIframeHidden(iframeNode, parentPanelNode)
+ *        * iframeNode: The iframe.
+ *        * parentPanelNode: The panel node in which the iframe is shown.
+ * @param onIframeShowing (function, optional)
+ *        Called when the action's iframe is showing to the user:
+ *        onIframeShowing(iframeNode, parentPanelNode)
+ *        * iframeNode: The iframe.
+ *        * parentPanelNode: The panel node in which the iframe is shown.
+ * @param onLocationChange (function, optional)
+ *        Called after tab switch or when the current <browser>'s location
+ *        changes:
+ *        onLocationChange(browserWindow)
+ *        * browserWindow: The browser window containing the tab switch or
+ *          changed <browser>.
+ * @param onPlacedInPanel (function, optional)
+ *        Called when the action is added to the page action panel in a browser
+ *        window:
+ *        onPlacedInPanel(buttonNode)
+ *        * buttonNode: The action's node in the page action panel.
+ * @param onPlacedInUrlbar (function, optional)
+ *        Called when the action is added to the urlbar in a browser window:
+ *        onPlacedInUrlbar(buttonNode)
+ *        * buttonNode: The action's node in the urlbar.
+ * @param onRemovedFromWindow (function, optional)
+ *        Called after the action is removed from a browser window:
+ *        onRemovedFromWindow(browserWindow)
+ *        * browserWindow: The browser window that the action was removed from.
+ * @param onShowingInPanel (function, optional)
+ *        Called when a browser window's page action panel is showing:
+ *        onShowingInPanel(buttonNode)
+ *        * buttonNode: The action's node in the page action panel.
+ * @param onSubviewPlaced (function, optional)
+ *        Called when the action's subview is added to its parent panel in a
+ *        browser window:
+ *        onSubviewPlaced(panelViewNode)
+ *        * panelViewNode: The subview's panelview node.
+ * @param onSubviewShowing (function, optional)
+ *        Called when the action's subview is showing in a browser window:
+ *        onSubviewShowing(panelViewNode)
+ *        * panelViewNode: The subview's panelview node.
+ * @param pinnedToUrlbar (bool, optional)
+ *        Pass true to pin the action to the urlbar.  An action is shown in the
+ *        urlbar if it's pinned and not disabled.  False by default.
+ * @param tooltip (string, optional)
+ *        The action's button tooltip text.
+ * @param urlbarIDOverride (string, optional)
+ *        Usually the ID of the action's button in the urlbar will be generated
+ *        automatically.  Pass a string for this property to override that with
+ *        your own ID.
+ * @param wantsIframe (bool, optional)
+ *        Pass true to make an action that shows an iframe in a panel when
+ *        clicked.
+ * @param wantsSubview (bool, optional)
+ *        Pass true to make an action that shows a panel subview when clicked.
+ * @param disablePrivateBrowsing (bool, optional)
+ *        Pass true to prevent the action from showing in a private browsing window.
+ */
+function Action(options) {
+  setProperties(this, options, {
+    id: true,
+    title: false,
+    anchorIDOverride: false,
+    disabled: false,
+    extensionID: false,
+    iconURL: false,
+    isBadged: false,
+    labelForHistogram: false,
+    onBeforePlacedInWindow: false,
+    onCommand: false,
+    onIframeHiding: false,
+    onIframeHidden: false,
+    onIframeShowing: false,
+    onLocationChange: false,
+    onPlacedInPanel: false,
+    onPlacedInUrlbar: false,
+    onRemovedFromWindow: false,
+    onShowingInPanel: false,
+    onSubviewPlaced: false,
+    onSubviewShowing: false,
+    onPinToUrlbarToggled: false,
+    pinnedToUrlbar: false,
+    tooltip: false,
+    urlbarIDOverride: false,
+    wantsIframe: false,
+    wantsSubview: false,
+    disablePrivateBrowsing: false,
+
+    // private
+
+    // (string, optional)
+    // The ID of another action before which to insert this new action in the
+    // panel.
+    _insertBeforeActionID: false,
+
+    // (bool, optional)
+    // True if this isn't really an action but a separator to be shown in the
+    // page action panel.
+    _isSeparator: false,
+
+    // (bool, optional)
+    // Transient actions have a couple of special properties: (1) They stick to
+    // the bottom of the panel, and (2) they're hidden in the panel when they're
+    // disabled.  Other than that they behave like other actions.
+    _transient: false,
+
+    // (bool, optional)
+    // True if the action's urlbar button is defined in markup.  In that case, a
+    // node with the action's urlbar node ID should already exist in the DOM
+    // (either the auto-generated ID or urlbarIDOverride).  That node will be
+    // shown when the action is added to the urlbar and hidden when the action
+    // is removed from the urlbar.
+    _urlbarNodeInMarkup: false,
+  });
+
+  /**
+   * A cache of the pre-computed CSS variable values for a given icon
+   * URLs object, as passed to _createIconProperties.
+   */
+  this._iconProperties = new WeakMap();
+
+  /**
+   * The global values for the action properties.
+   */
+  this._globalProps = {
+    disabled: this._disabled,
+    iconURL: this._iconURL,
+    iconProps: this._createIconProperties(this._iconURL),
+    title: this._title,
+    tooltip: this._tooltip,
+    wantsSubview: this._wantsSubview,
+  };
+
+  /**
+   * A mapping of window-specific action property objects, each of which
+   * derives from the _globalProps object.
+   */
+  this._windowProps = new WeakMap();
+}
+
+Action.prototype = {
+  /**
+   * The ID of the action's parent extension (string)
+   */
+  get extensionID() {
+    return this._extensionID;
+  },
+
+  /**
+   * The action's ID (string)
+   */
+  get id() {
+    return this._id;
+  },
+
+  get disablePrivateBrowsing() {
+    return !!this._disablePrivateBrowsing;
+  },
+
+  /**
+   * Verifies that the action can be shown in a private window.  For
+   * extensions, verifies the extension has access to the window.
+   */
+  canShowInWindow(browserWindow) {
+    if (this._extensionID) {
+      let policy = WebExtensionPolicy.getByID(this._extensionID);
+      if (!policy.canAccessWindow(browserWindow)) {
+        return false;
+      }
+    }
+    return !(
+      this.disablePrivateBrowsing &&
+      lazy.PrivateBrowsingUtils.isWindowPrivate(browserWindow)
+    );
+  },
+
+  /**
+   * True if the action is pinned to the urlbar.  The action is shown in the
+   * urlbar if it's pinned and not disabled.  (bool)
+   */
+  get pinnedToUrlbar() {
+    return this._pinnedToUrlbar || false;
+  },
+  set pinnedToUrlbar(shown) {
+    if (this.pinnedToUrlbar != shown) {
+      this._pinnedToUrlbar = shown;
+      PageActions.onActionToggledPinnedToUrlbar(this);
+      this.onPinToUrlbarToggled();
+    }
+  },
+
+  /**
+   * The action's disabled state (bool)
+   */
+  getDisabled(browserWindow = null) {
+    return !!this._getProperties(browserWindow).disabled;
+  },
+  setDisabled(value, browserWindow = null) {
+    return this._setProperty("disabled", !!value, browserWindow);
+  },
+
+  /**
+   * The action's icon URL string, or an object mapping sizes to URL strings
+   * (string or object)
+   */
+  getIconURL(browserWindow = null) {
+    return this._getProperties(browserWindow).iconURL;
+  },
+  setIconURL(value, browserWindow = null) {
+    let props = this._getProperties(browserWindow, !!browserWindow);
+    props.iconURL = value;
+    props.iconProps = this._createIconProperties(value);
+
+    this._updateProperty("iconURL", props.iconProps, browserWindow);
+    return value;
+  },
+
+  /**
+   * The set of CSS variables which define the action's icons in various
+   * sizes. This is generated automatically from the iconURL property.
+   */
+  getIconProperties(browserWindow = null) {
+    return this._getProperties(browserWindow).iconProps;
+  },
+
+  _createIconProperties(urls) {
+    if (urls && typeof urls == "object") {
+      let props = this._iconProperties.get(urls);
+      if (!props) {
+        props = Object.freeze({
+          "--pageAction-image": `image-set(
+            ${escapeCSSURL(this._iconURLForSize(urls, 16))},
+            ${escapeCSSURL(this._iconURLForSize(urls, 32))} 2x
+          )`,
+        });
+        this._iconProperties.set(urls, props);
+      }
+      return props;
+    }
+
+    let cssURL = urls ? escapeCSSURL(urls) : null;
+    return Object.freeze({
+      "--pageAction-image": cssURL,
+    });
+  },
+
+  /**
+   * The action's title (string). Note, built in actions will
+   * not have a title property.
+   */
+  getTitle(browserWindow = null) {
+    return this._getProperties(browserWindow).title;
+  },
+  setTitle(value, browserWindow = null) {
+    return this._setProperty("title", value, browserWindow);
+  },
+
+  /**
+   * The action's tooltip (string)
+   */
+  getTooltip(browserWindow = null) {
+    return this._getProperties(browserWindow).tooltip;
+  },
+  setTooltip(value, browserWindow = null) {
+    return this._setProperty("tooltip", value, browserWindow);
+  },
+
+  /**
+   * Whether the action wants a subview (bool)
+   */
+  getWantsSubview(browserWindow = null) {
+    return !!this._getProperties(browserWindow).wantsSubview;
+  },
+  setWantsSubview(value, browserWindow = null) {
+    return this._setProperty("wantsSubview", !!value, browserWindow);
+  },
+
+  /**
+   * Sets a property, optionally for a particular browser window.
+   *
+   * @param  name (string, required)
+   *         The (non-underscored) name of the property.
+   * @param  value
+   *         The value.
+   * @param  browserWindow (DOM window, optional)
+   *         If given, then the property will be set in this window's state, not
+   *         globally.
+   */
+  _setProperty(name, value, browserWindow) {
+    let props = this._getProperties(browserWindow, !!browserWindow);
+    props[name] = value;
+
+    this._updateProperty(name, value, browserWindow);
+    return value;
+  },
+
+  _updateProperty(name, value, browserWindow) {
+    // This may be called before the action has been added.
+    if (PageActions.actionForID(this.id)) {
+      for (let bpa of allBrowserPageActions(browserWindow)) {
+        bpa.updateAction(this, name, { value });
+      }
+    }
+  },
+
+  /**
+   * Returns the properties object for the given window, if it exists,
+   * or the global properties object if no window-specific properties
+   * exist.
+   *
+   * @param {Window?} window
+   *        The window for which to return the properties object, or
+   *        null to return the global properties object.
+   * @param {bool} [forceWindowSpecific = false]
+   *        If true, always returns a window-specific properties object.
+   *        If a properties object does not exist for the given window,
+   *        one is created and cached.
+   * @returns {object}
+   */
+  _getProperties(window, forceWindowSpecific = false) {
+    let props = window && this._windowProps.get(window);
+
+    if (!props && forceWindowSpecific) {
+      props = Object.create(this._globalProps);
+      this._windowProps.set(window, props);
+    }
+
+    return props || this._globalProps;
+  },
+
+  /**
+   * Override for the ID of the action's activated-action panel anchor (string)
+   */
+  get anchorIDOverride() {
+    return this._anchorIDOverride;
+  },
+
+  /**
+   * Override for the ID of the action's urlbar node (string)
+   */
+  get urlbarIDOverride() {
+    return this._urlbarIDOverride;
+  },
+
+  /**
+   * True if the action is shown in an iframe (bool)
+   */
+  get wantsIframe() {
+    return this._wantsIframe || false;
+  },
+
+  get isBadged() {
+    return this._isBadged || false;
+  },
+
+  get labelForHistogram() {
+    // The histogram label value has a length limit of 20 and restricted to a
+    // pattern. See MAX_LABEL_LENGTH and CPP_IDENTIFIER_PATTERN in
+    // toolkit/components/telemetry/parse_histograms.py
+    return (
+      this._labelForHistogram ||
+      this._id.replace(/_\w{1}/g, match => match[1].toUpperCase()).substr(0, 20)
+    );
+  },
+
+  /**
+   * Selects the best matching icon from the given URLs object for the
+   * given preferred size.
+   *
+   * @param {object} urls
+   *        An object containing square icons of various sizes. The name
+   *        of each property is its width, and the value is its image URL.
+   * @param {integer} peferredSize
+   *        The preferred icon width. The most appropriate icon in the
+   *        urls object will be chosen to match that size. An exact
+   *        match will be preferred, followed by an icon exactly double
+   *        the size, followed by the smallest icon larger than the
+   *        preferred size, followed by the largest available icon.
+   * @returns {string}
+   *        The chosen icon URL.
+   */
+  _iconURLForSize(urls, preferredSize) {
+    // This case is copied from ExtensionParent.jsm so that our image logic is
+    // the same, so that WebExtensions page action tests that deal with icons
+    // pass.
+    let bestSize = null;
+    if (urls[preferredSize]) {
+      bestSize = preferredSize;
+    } else if (urls[2 * preferredSize]) {
+      bestSize = 2 * preferredSize;
+    } else {
+      let sizes = Object.keys(urls)
+        .map(key => parseInt(key, 10))
+        .sort((a, b) => a - b);
+      bestSize =
+        sizes.find(candidate => candidate > preferredSize) || sizes.pop();
+    }
+    return urls[bestSize];
+  },
+
+  /**
+   * Performs the command for an action.  If the action has an onCommand
+   * handler, then it's called.  If the action has a subview or iframe, then a
+   * panel is opened, displaying the subview or iframe.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The browser window in which to perform the action.
+   */
+  doCommand(browserWindow) {
+    browserPageActions(browserWindow).doCommandForAction(this);
+  },
+
+  /**
+   * Call this when before placing the action in the window.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The browser window the action will be placed in.
+   */
+  onBeforePlacedInWindow(browserWindow) {
+    if (this._onBeforePlacedInWindow) {
+      this._onBeforePlacedInWindow(browserWindow);
+    }
+  },
+
+  /**
+   * Call this when the user activates the action.
+   *
+   * @param  event (DOM event, required)
+   *         The triggering event.
+   * @param  buttonNode (DOM node, required)
+   *         The action's panel or urlbar button node that was clicked.
+   */
+  onCommand(event, buttonNode) {
+    if (this._onCommand) {
+      this._onCommand(event, buttonNode);
+    }
+  },
+
+  /**
+   * Call this when the action's iframe is hiding.
+   *
+   * @param  iframeNode (DOM node, required)
+   *         The iframe that's hiding.
+   * @param  parentPanelNode (DOM node, required)
+   *         The panel in which the iframe is hiding.
+   */
+  onIframeHiding(iframeNode, parentPanelNode) {
+    if (this._onIframeHiding) {
+      this._onIframeHiding(iframeNode, parentPanelNode);
+    }
+  },
+
+  /**
+   * Call this when the action's iframe is hidden.
+   *
+   * @param  iframeNode (DOM node, required)
+   *         The iframe that's being hidden.
+   * @param  parentPanelNode (DOM node, required)
+   *         The panel in which the iframe is hidden.
+   */
+  onIframeHidden(iframeNode, parentPanelNode) {
+    if (this._onIframeHidden) {
+      this._onIframeHidden(iframeNode, parentPanelNode);
+    }
+  },
+
+  /**
+   * Call this when the action's iframe is showing.
+   *
+   * @param  iframeNode (DOM node, required)
+   *         The iframe that's being shown.
+   * @param  parentPanelNode (DOM node, required)
+   *         The panel in which the iframe is shown.
+   */
+  onIframeShowing(iframeNode, parentPanelNode) {
+    if (this._onIframeShowing) {
+      this._onIframeShowing(iframeNode, parentPanelNode);
+    }
+  },
+
+  /**
+   * Call this on tab switch or when the current <browser>'s location changes.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The browser window containing the tab switch or changed <browser>.
+   */
+  onLocationChange(browserWindow) {
+    if (this._onLocationChange) {
+      this._onLocationChange(browserWindow);
+    }
+  },
+
+  /**
+   * Call this when a DOM node for the action is added to the page action panel.
+   *
+   * @param  buttonNode (DOM node, required)
+   *         The action's panel button node.
+   */
+  onPlacedInPanel(buttonNode) {
+    if (this._onPlacedInPanel) {
+      this._onPlacedInPanel(buttonNode);
+    }
+  },
+
+  /**
+   * Call this when a DOM node for the action is added to the urlbar.
+   *
+   * @param  buttonNode (DOM node, required)
+   *         The action's urlbar button node.
+   */
+  onPlacedInUrlbar(buttonNode) {
+    if (this._onPlacedInUrlbar) {
+      this._onPlacedInUrlbar(buttonNode);
+    }
+  },
+
+  /**
+   * Call this when the DOM nodes for the action are removed from a browser
+   * window.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The browser window the action was removed from.
+   */
+  onRemovedFromWindow(browserWindow) {
+    if (this._onRemovedFromWindow) {
+      this._onRemovedFromWindow(browserWindow);
+    }
+  },
+
+  /**
+   * Call this when the action's button is shown in the page action panel.
+   *
+   * @param  buttonNode (DOM node, required)
+   *         The action's panel button node.
+   */
+  onShowingInPanel(buttonNode) {
+    if (this._onShowingInPanel) {
+      this._onShowingInPanel(buttonNode);
+    }
+  },
+
+  /**
+   * Call this when a panelview node for the action's subview is added to the
+   * DOM.
+   *
+   * @param  panelViewNode (DOM node, required)
+   *         The subview's panelview node.
+   */
+  onSubviewPlaced(panelViewNode) {
+    if (this._onSubviewPlaced) {
+      this._onSubviewPlaced(panelViewNode);
+    }
+  },
+
+  /**
+   * Call this when a panelview node for the action's subview is showing.
+   *
+   * @param  panelViewNode (DOM node, required)
+   *         The subview's panelview node.
+   */
+  onSubviewShowing(panelViewNode) {
+    if (this._onSubviewShowing) {
+      this._onSubviewShowing(panelViewNode);
+    }
+  },
+  /**
+   * Call this when an icon in the url is pinned or unpinned.
+   */
+  onPinToUrlbarToggled() {
+    if (this._onPinToUrlbarToggled) {
+      this._onPinToUrlbarToggled();
+    }
+  },
+
+  /**
+   * Removes the action's DOM nodes from all browser windows.
+   *
+   * PageActions will remember the action's urlbar placement, if any, after this
+   * method is called until app shutdown.  If the action is not added again
+   * before shutdown, then PageActions will discard the placement, and the next
+   * time the action is added, its placement will be reset.
+   */
+  remove() {
+    PageActions.onActionRemoved(this);
+  },
+
+  /**
+   * Returns whether the action should be shown in a given window's panel.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The window.
+   * @return True if the action should be shown and false otherwise.  Actions
+   *         are always shown in the panel unless they're both transient and
+   *         disabled.
+   */
+  shouldShowInPanel(browserWindow) {
+    // When Proton is enabled, the extension page actions should behave similarly
+    // to a transient action, and be hidden from the urlbar overflow menu if they
+    // are disabled (as in the urlbar when the overflow menu isn't available)
+    //
+    // TODO(Bug 1704139): as a follow up we may look into just set on all
+    // extensions pageActions `_transient: true`, at least once we sunset
+    // the proton preference and we don't need the pre-Proton behavior anymore,
+    // and remove this special case.
+    const isProtonExtensionAction = this.extensionID;
+
+    return (
+      (!(this.__transient || isProtonExtensionAction) ||
+        !this.getDisabled(browserWindow)) &&
+      this.canShowInWindow(browserWindow)
+    );
+  },
+
+  /**
+   * Returns whether the action should be shown in a given window's urlbar.
+   *
+   * @param  browserWindow (DOM window, required)
+   *         The window.
+   * @return True if the action should be shown and false otherwise.  The action
+   *         should be shown if it's both pinned and not disabled.
+   */
+  shouldShowInUrlbar(browserWindow) {
+    return (
+      this.pinnedToUrlbar &&
+      !this.getDisabled(browserWindow) &&
+      this.canShowInWindow(browserWindow)
+    );
+  },
+
+  get _isBuiltIn() {
+    let builtInIDs = ["screenshots_mozilla_org"].concat(
+      gBuiltInActions.filter(a => !a.__isSeparator).map(a => a.id)
+    );
+    return builtInIDs.includes(this.id);
+  },
+
+  get _isMozillaAction() {
+    return this._isBuiltIn || this.id == "webcompat-reporter_mozilla_org";
+  },
+};
+
+PageActions.Action = Action;
+
+PageActions.ACTION_ID_BUILT_IN_SEPARATOR = ACTION_ID_BUILT_IN_SEPARATOR;
+PageActions.ACTION_ID_TRANSIENT_SEPARATOR = ACTION_ID_TRANSIENT_SEPARATOR;
+
+// These are only necessary so that the test can use them.
+PageActions.ACTION_ID_BOOKMARK = ACTION_ID_BOOKMARK;
+PageActions.PREF_PERSISTED_ACTIONS = PREF_PERSISTED_ACTIONS;
+
+// Sorted in the order in which they should appear in the page action panel.
+// Does not include the page actions of extensions bundled with the browser.
+// They're added by the relevant extension code.
+// NOTE: If you add items to this list (or system add-on actions that we
+// want to keep track of), make sure to also update Histograms.json for the
+// new actions.
+var gBuiltInActions;
+
+PageActions._initBuiltInActions = function () {
+  gBuiltInActions = [
+    // bookmark
+    {
+      id: ACTION_ID_BOOKMARK,
+      urlbarIDOverride: "star-button-box",
+      _urlbarNodeInMarkup: true,
+      pinnedToUrlbar: true,
+      onShowingInPanel(buttonNode) {
+        browserPageActions(buttonNode).bookmark.onShowingInPanel(buttonNode);
+      },
+      onCommand(event, buttonNode) {
+        browserPageActions(buttonNode).bookmark.onCommand(event, buttonNode);
+      },
+    },
+  ];
+};
+
+/**
+ * Gets a BrowserPageActions object in a browser window.
+ *
+ * @param  obj
+ *         Either a DOM node or a browser window.
+ * @return The BrowserPageActions object in the browser window related to the
+ *         given object.
+ */
+function browserPageActions(obj) {
+  if (obj.BrowserPageActions) {
+    return obj.BrowserPageActions;
+  }
+  return obj.ownerGlobal.BrowserPageActions;
+}
+
+/**
+ * A generator function for all open browser windows.
+ *
+ * @param browserWindow (DOM window, optional)
+ *        If given, then only this window will be yielded.  That may sound
+ *        pointless, but it can make callers nicer to write since they don't
+ *        need two separate cases, one where a window is given and another where
+ *        it isn't.
+ */
+function* allBrowserWindows(browserWindow = null) {
+  if (browserWindow) {
+    yield browserWindow;
+    return;
+  }
+  yield* Services.wm.getEnumerator("navigator:browser");
+}
+
+/**
+ * A generator function for BrowserPageActions objects in all open windows.
+ *
+ * @param browserWindow (DOM window, optional)
+ *        If given, then the BrowserPageActions for only this window will be
+ *        yielded.
+ */
+function* allBrowserPageActions(browserWindow = null) {
+  for (let win of allBrowserWindows(browserWindow)) {
+    yield browserPageActions(win);
+  }
+}
+
+/**
+ * A simple function that sets properties on a given object while doing basic
+ * required-properties checking.  If a required property isn't specified in the
+ * given options object, or if the options object has properties that aren't in
+ * the given schema, then an error is thrown.
+ *
+ * @param  obj
+ *         The object to set properties on.
+ * @param  options
+ *         An options object supplied by the consumer.
+ * @param  schema
+ *         An object a property for each required and optional property.  The
+ *         keys are property names; the value of a key is a bool that is true if
+ *         the property is required.
+ */
+function setProperties(obj, options, schema) {
+  for (let name in schema) {
+    let required = schema[name];
+    if (required && !(name in options)) {
+      throw new Error(`'${name}' must be specified`);
+    }
+    let nameInObj = "_" + name;
+    if (name[0] == "_") {
+      // The property is "private".  If it's defined in the options, then define
+      // it on obj exactly as it's defined on options.
+      if (name in options) {
+        obj[nameInObj] = options[name];
+      }
+    } else {
+      // The property is "public".  Make sure the property is defined on obj.
+      obj[nameInObj] = options[name] || null;
+    }
+  }
+  for (let name in options) {
+    if (!(name in schema)) {
+      throw new Error(`Unrecognized option '${name}'`);
+    }
+  }
+}
diff --git a/browser/modules/PartnerLinkAttribution.sys.mjs b/browser/modules/PartnerLinkAttribution.sys.mjs
new file mode 100644
index 0000000000..4f0c702396
--- /dev/null
+++ b/browser/modules/PartnerLinkAttribution.sys.mjs
@@ -0,0 +1,77 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Region: "resource://gre/modules/Region.sys.mjs",
+});
+
+export const CONTEXTUAL_SERVICES_PING_TYPES = {
+  TOPSITES_IMPRESSION: "topsites-impression",
+  TOPSITES_SELECTION: "topsites-click",
+  QS_BLOCK: "quicksuggest-block",
+  QS_IMPRESSION: "quicksuggest-impression",
+  QS_SELECTION: "quicksuggest-click",
+};
+
+export var PartnerLinkAttribution = {
+  /**
+   * Sends an attribution request to an anonymizing proxy.
+   *
+   * @param {string} targetURL
+   *   The URL we are routing through the anonmyzing proxy.
+   * @param {string} source
+   *   The source of the anonmized request, e.g. "urlbar".
+   * @param {string} [campaignID]
+   *   The campaign ID for attribution. This should be a valid path on the
+   *   anonymizing proxy. For example, if `campaignID` was `foo`, we'd send an
+   *   attribution request to https://topsites.mozilla.com/cid/foo.
+   *   Optional. If it's not provided, we default to the topsites campaign.
+   */
+  async makeRequest({ targetURL, source, campaignID }) {
+    let partner = targetURL.match(/^https?:\/\/(?:www.)?([^.]*)/)[1];
+
+    function record(method, objectString) {
+      recordTelemetryEvent({
+        method,
+        objectString,
+        value: partner,
+      });
+    }
+    record("click", source);
+
+    let attributionUrl = Services.prefs.getStringPref(
+      "browser.partnerlink.attributionURL"
+    );
+    if (!attributionUrl) {
+      record("attribution", "abort");
+      return;
+    }
+
+    // The default campaign is topsites.
+    if (!campaignID) {
+      campaignID = Services.prefs.getStringPref(
+        "browser.partnerlink.campaign.topsites"
+      );
+    }
+    attributionUrl = attributionUrl + campaignID;
+    let result = await sendRequest(attributionUrl, source, targetURL);
+    record("attribution", result ? "success" : "failure");
+  },
+};
+
+async function sendRequest(attributionUrl, source, targetURL) {
+  const request = new Request(attributionUrl);
+  request.headers.set("X-Region", lazy.Region.home);
+  request.headers.set("X-Source", source);
+  request.headers.set("X-Target-URL", targetURL);
+  const response = await fetch(request);
+  return response.ok;
+}
+
+function recordTelemetryEvent({ method, objectString, value }) {
+  Services.telemetry.setEventRecordingEnabled("partner_link", true);
+  Services.telemetry.recordEvent("partner_link", method, objectString, value);
+}
diff --git a/browser/modules/PermissionUI.sys.mjs b/browser/modules/PermissionUI.sys.mjs
new file mode 100644
index 0000000000..2f44073f43
--- /dev/null
+++ b/browser/modules/PermissionUI.sys.mjs
@@ -0,0 +1,1432 @@
+/* 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/. */
+
+/**
+ * PermissionUI is responsible for exposing both a prototype
+ * PermissionPrompt that can be used by arbitrary browser
+ * components and add-ons, but also hosts the implementations of
+ * built-in permission prompts.
+ *
+ * If you're developing a feature that requires web content to ask
+ * for special permissions from the user, this module is for you.
+ *
+ * Suppose a system add-on wants to add a new prompt for a new request
+ * for getting more low-level access to the user's sound card, and the
+ * permission request is coming up from content by way of the
+ * nsContentPermissionHelper. The system add-on could then do the following:
+ *
+ * const { Integration } = ChromeUtils.importESModule(
+ *   "resource://gre/modules/Integration.sys.mjs"
+ * );
+ * const { PermissionUI } = ChromeUtils.import(
+ *   "resource:///modules/PermissionUI.jsm"
+ * );
+ *
+ * const SoundCardIntegration = base => {
+ *   let soundCardObj = {
+ *     createPermissionPrompt(type, request) {
+ *       if (type != "sound-api") {
+ *         return super.createPermissionPrompt(...arguments);
+ *       }
+ *
+ *       let permissionPrompt = {
+ *         get permissionKey() {
+ *           return "sound-permission";
+ *         }
+ *         // etc - see the documentation for PermissionPrompt for
+ *         // a better idea of what things one can and should override.
+ *       };
+ *       Object.setPrototypeOf(
+ *         permissionPrompt,
+ *         PermissionUI.PermissionPromptForRequest
+ *       );
+ *       return permissionPrompt;
+ *     },
+ *   };
+ *   Object.setPrototypeOf(soundCardObj, base);
+ *   return soundCardObj;
+ * };
+ *
+ * // Add-on startup:
+ * Integration.contentPermission.register(SoundCardIntegration);
+ * // ...
+ * // Add-on shutdown:
+ * Integration.contentPermission.unregister(SoundCardIntegration);
+ *
+ * Note that PermissionPromptForRequest must be used as the
+ * prototype, since the prompt is wrapping an nsIContentPermissionRequest,
+ * and going through nsIContentPermissionPrompt.
+ *
+ * It is, however, possible to take advantage of PermissionPrompt without
+ * having to go through nsIContentPermissionPrompt or with a
+ * nsIContentPermissionRequest. The PermissionPrompt can be
+ * imported, subclassed, and have prompt() called directly, without
+ * the caller having called into createPermissionPrompt.
+ */
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  SitePermissions: "resource:///modules/SitePermissions.sys.mjs",
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "IDNService",
+  "@mozilla.org/network/idn-service;1",
+  "nsIIDNService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "ContentPrefService2",
+  "@mozilla.org/content-pref/service;1",
+  "nsIContentPrefService2"
+);
+ChromeUtils.defineLazyGetter(lazy, "gBrowserBundle", function () {
+  return Services.strings.createBundle(
+    "chrome://browser/locale/browser.properties"
+  );
+});
+
+import { SITEPERMS_ADDON_PROVIDER_PREF } from "resource://gre/modules/addons/siteperms-addon-utils.sys.mjs";
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "sitePermsAddonsProviderEnabled",
+  SITEPERMS_ADDON_PROVIDER_PREF,
+  false
+);
+
+/**
+ * PermissionPrompt should be subclassed by callers that
+ * want to display prompts to the user. See each method and property
+ * below for guidance on what to override.
+ *
+ * Note that if you're creating a prompt for an
+ * nsIContentPermissionRequest, you'll want to subclass
+ * PermissionPromptForRequest instead.
+ */
+class PermissionPrompt {
+  /**
+   * Returns the associated <xul:browser> for the request. This should
+   * work for the e10s and non-e10s case.
+   *
+   * Subclasses must override this.
+   *
+   * @return {<xul:browser>}
+   */
+  get browser() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * Returns the nsIPrincipal associated with the request.
+   *
+   * Subclasses must override this.
+   *
+   * @return {nsIPrincipal}
+   */
+  get principal() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * Indicates the type of the permission request from content. This type might
+   * be different from the permission key used in the permissions database.
+   */
+  get type() {
+    return undefined;
+  }
+
+  /**
+   * If the nsIPermissionManager is being queried and written
+   * to for this permission request, set this to the key to be
+   * used. If this is undefined, no integration with temporary
+   * permissions infrastructure will be provided.
+   *
+   * Note that if a permission is set, in any follow-up
+   * prompting within the expiry window of that permission,
+   * the prompt will be skipped and the allow or deny choice
+   * will be selected automatically.
+   */
+  get permissionKey() {
+    return undefined;
+  }
+
+  /**
+   * If true, user permissions will be read from and written to.
+   * When this is false, we still provide integration with
+   * infrastructure such as temporary permissions. permissionKey should
+   * still return a valid name in those cases for that integration to work.
+   */
+  get usePermissionManager() {
+    return true;
+  }
+
+  /**
+   * Indicates what URI should be used as the scope when using temporary
+   * permissions. If undefined, it defaults to the browser.currentURI.
+   */
+  get temporaryPermissionURI() {
+    return undefined;
+  }
+
+  /**
+   * These are the options that will be passed to the PopupNotification when it
+   * is shown. See the documentation of `PopupNotifications_show` in
+   * PopupNotifications.sys.mjs for details.
+   *
+   * Note that prompt() will automatically set displayURI to
+   * be the URI of the requesting pricipal, unless the displayURI is exactly
+   * set to false.
+   */
+  get popupOptions() {
+    return {};
+  }
+
+  /**
+   * If true, automatically denied permission requests will
+   * spawn a "post-prompt" that allows the user to correct the
+   * automatic denial by giving permanent permission access to
+   * the site.
+   *
+   * Note that if this function returns true, the permissionKey
+   * and postPromptActions attributes must be implemented.
+   */
+  get postPromptEnabled() {
+    return false;
+  }
+
+  /**
+   * If true, the prompt will be cancelled automatically unless
+   * request.hasValidTransientUserGestureActivation is true.
+   */
+  get requiresUserInput() {
+    return false;
+  }
+
+  /**
+   * PopupNotification requires a unique ID to open the notification.
+   * You must return a unique ID string here, for which PopupNotification
+   * will then create a <xul:popupnotification> node with the ID
+   * "<notificationID>-notification".
+   *
+   * If there's a custom <xul:popupnotification> you're hoping to show,
+   * then you need to make sure its ID has the "-notification" suffix,
+   * and then return the prefix here.
+   *
+   * See PopupNotifications.sys.mjs for more details.
+   *
+   * @return {string}
+   *         The unique ID that will be used to as the
+   *         "<unique ID>-notification" ID for the <xul:popupnotification>
+   *         to use or create.
+   */
+  get notificationID() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * The ID of the element to anchor the PopupNotification to.
+   *
+   * @return {string}
+   */
+  get anchorID() {
+    return "default-notification-icon";
+  }
+
+  /**
+   * The message to show to the user in the PopupNotification, see
+   * `PopupNotifications_show` in PopupNotifications.sys.mjs.
+   *
+   * Subclasses must override this.
+   *
+   * @return {string}
+   */
+  get message() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * Provides the preferred name to use in the permission popups,
+   * based on the principal URI (the URI.hostPort for any URI scheme
+   * besides the moz-extension one which should default to the
+   * extension name).
+   */
+  getPrincipalName(principal = this.principal) {
+    if (principal.addonPolicy) {
+      return principal.addonPolicy.name;
+    }
+
+    return principal.hostPort;
+  }
+
+  /**
+   * This will be called if the request is to be cancelled.
+   *
+   * Subclasses only need to override this if they provide a
+   * permissionKey.
+   */
+  cancel() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * This will be called if the request is to be allowed.
+   *
+   * Subclasses only need to override this if they provide a
+   * permissionKey.
+   */
+  allow() {
+    throw new Error("Not implemented.");
+  }
+
+  /**
+   * The actions that will be displayed in the PopupNotification
+   * via a dropdown menu. The first item in this array will be
+   * the default selection. Each action is an Object with the
+   * following properties:
+   *
+   *  label (string):
+   *    The label that will be displayed for this choice.
+   *  accessKey (string):
+   *    The access key character that will be used for this choice.
+   *  action (SitePermissions state)
+   *    The action that will be associated with this choice.
+   *    This should be either SitePermissions.ALLOW or SitePermissions.BLOCK.
+   *  scope (SitePermissions scope)
+   *    The scope of the associated action (e.g. SitePermissions.SCOPE_PERSISTENT)
+   *
+   *  callback (function, optional)
+   *    A callback function that will fire if the user makes this choice, with
+   *    a single parameter, state. State is an Object that contains the property
+   *    checkboxChecked, which identifies whether the checkbox to remember this
+   *    decision was checked.
+   */
+  get promptActions() {
+    return [];
+  }
+
+  /**
+   * The actions that will be displayed in the PopupNotification
+   * for post-prompt notifications via a dropdown menu.
+   * The first item in this array will be the default selection.
+   * Each action is an Object with the following properties:
+   *
+   *  label (string):
+   *    The label that will be displayed for this choice.
+   *  accessKey (string):
+   *    The access key character that will be used for this choice.
+   *  action (SitePermissions state)
+   *    The action that will be associated with this choice.
+   *    This should be either SitePermissions.ALLOW or SitePermissions.BLOCK.
+   *    Note that the scope of this action will always be persistent.
+   *
+   *  callback (function, optional)
+   *    A callback function that will fire if the user makes this choice.
+   */
+  get postPromptActions() {
+    return null;
+  }
+
+  /**
+   * If the prompt will be shown to the user, this callback will
+   * be called just before. Subclasses may want to override this
+   * in order to, for example, bump a counter Telemetry probe for
+   * how often a particular permission request is seen.
+   *
+   * If this returns false, it cancels the process of showing the prompt.  In
+   * that case, it is the responsibility of the onBeforeShow() implementation
+   * to ensure that allow() or cancel() are called on the object appropriately.
+   */
+  onBeforeShow() {
+    return true;
+  }
+
+  /**
+   * If the prompt was shown to the user, this callback will be called just
+   * after it's been shown.
+   */
+  onShown() {}
+
+  /**
+   * If the prompt was shown to the user, this callback will be called just
+   * after it's been hidden.
+   */
+  onAfterShow() {}
+
+  /**
+   * Will determine if a prompt should be shown to the user, and if so,
+   * will show it.
+   *
+   * If a permissionKey is defined prompt() might automatically
+   * allow or cancel itself based on the user's current
+   * permission settings without displaying the prompt.
+   *
+   * If the permission is not already set and the <xul:browser> that the request
+   * is associated with does not belong to a browser window with the
+   * PopupNotifications global set, the prompt request is ignored.
+   */
+  prompt() {
+    // We ignore requests from non-nsIStandardURLs
+    let requestingURI = this.principal.URI;
+    if (!(requestingURI instanceof Ci.nsIStandardURL)) {
+      return;
+    }
+
+    if (this.usePermissionManager && this.permissionKey) {
+      // If we're reading and setting permissions, then we need
+      // to check to see if we already have a permission setting
+      // for this particular principal.
+      let { state } = lazy.SitePermissions.getForPrincipal(
+        this.principal,
+        this.permissionKey,
+        this.browser,
+        this.temporaryPermissionURI
+      );
+
+      if (state == lazy.SitePermissions.BLOCK) {
+        this.cancel();
+        return;
+      }
+
+      if (
+        state == lazy.SitePermissions.ALLOW &&
+        !this.request.isRequestDelegatedToUnsafeThirdParty
+      ) {
+        this.allow();
+        return;
+      }
+    } else if (this.permissionKey) {
+      // If we're reading a permission which already has a temporary value,
+      // see if we can use the temporary value.
+      let { state } = lazy.SitePermissions.getForPrincipal(
+        null,
+        this.permissionKey,
+        this.browser,
+        this.temporaryPermissionURI
+      );
+
+      if (state == lazy.SitePermissions.BLOCK) {
+        this.cancel();
+        return;
+      }
+    }
+
+    if (
+      this.requiresUserInput &&
+      !this.request.hasValidTransientUserGestureActivation
+    ) {
+      if (this.postPromptEnabled) {
+        this.postPrompt();
+      }
+      this.cancel();
+      return;
+    }
+
+    let chromeWin = this.browser.ownerGlobal;
+    if (!chromeWin.PopupNotifications) {
+      this.cancel();
+      return;
+    }
+
+    // Transform the PermissionPrompt actions into PopupNotification actions.
+    let popupNotificationActions = [];
+    for (let promptAction of this.promptActions) {
+      let action = {
+        label: promptAction.label,
+        accessKey: promptAction.accessKey,
+        callback: state => {
+          if (promptAction.callback) {
+            promptAction.callback();
+          }
+
+          if (this.usePermissionManager && this.permissionKey) {
+            if (
+              (state && state.checkboxChecked && state.source != "esc-press") ||
+              promptAction.scope == lazy.SitePermissions.SCOPE_PERSISTENT
+            ) {
+              // Permanently store permission.
+              let scope = lazy.SitePermissions.SCOPE_PERSISTENT;
+              // Only remember permission for session if in PB mode.
+              if (lazy.PrivateBrowsingUtils.isBrowserPrivate(this.browser)) {
+                scope = lazy.SitePermissions.SCOPE_SESSION;
+              }
+              lazy.SitePermissions.setForPrincipal(
+                this.principal,
+                this.permissionKey,
+                promptAction.action,
+                scope
+              );
+            } else if (promptAction.action == lazy.SitePermissions.BLOCK) {
+              // Temporarily store BLOCK permissions only
+              // SitePermissions does not consider subframes when storing temporary
+              // permissions on a tab, thus storing ALLOW could be exploited.
+              lazy.SitePermissions.setForPrincipal(
+                this.principal,
+                this.permissionKey,
+                promptAction.action,
+                lazy.SitePermissions.SCOPE_TEMPORARY,
+                this.browser
+              );
+            }
+
+            // Grant permission if action is ALLOW.
+            if (promptAction.action == lazy.SitePermissions.ALLOW) {
+              this.allow();
+            } else {
+              this.cancel();
+            }
+          } else if (this.permissionKey) {
+            // TODO: Add support for permitTemporaryAllow
+            if (promptAction.action == lazy.SitePermissions.BLOCK) {
+              // Temporarily store BLOCK permissions.
+              // We don't consider subframes when storing temporary
+              // permissions on a tab, thus storing ALLOW could be exploited.
+              lazy.SitePermissions.setForPrincipal(
+                null,
+                this.permissionKey,
+                promptAction.action,
+                lazy.SitePermissions.SCOPE_TEMPORARY,
+                this.browser
+              );
+            }
+          }
+        },
+      };
+      if (promptAction.dismiss) {
+        action.dismiss = promptAction.dismiss;
+      }
+
+      popupNotificationActions.push(action);
+    }
+
+    this.#showNotification(popupNotificationActions);
+  }
+
+  postPrompt() {
+    let browser = this.browser;
+    let principal = this.principal;
+    let chromeWin = browser.ownerGlobal;
+    if (!chromeWin.PopupNotifications) {
+      return;
+    }
+
+    if (!this.permissionKey) {
+      throw new Error("permissionKey is required to show a post-prompt");
+    }
+
+    if (!this.postPromptActions) {
+      throw new Error("postPromptActions are required to show a post-prompt");
+    }
+
+    // Transform the PermissionPrompt actions into PopupNotification actions.
+    let popupNotificationActions = [];
+    for (let promptAction of this.postPromptActions) {
+      let action = {
+        label: promptAction.label,
+        accessKey: promptAction.accessKey,
+        callback: state => {
+          if (promptAction.callback) {
+            promptAction.callback();
+          }
+
+          // Post-prompt permissions are stored permanently by default.
+          // Since we can not reply to the original permission request anymore,
+          // the page will need to listen for permission changes which are triggered
+          // by permanent entries in the permission manager.
+          let scope = lazy.SitePermissions.SCOPE_PERSISTENT;
+          // Only remember permission for session if in PB mode.
+          if (lazy.PrivateBrowsingUtils.isBrowserPrivate(browser)) {
+            scope = lazy.SitePermissions.SCOPE_SESSION;
+          }
+          lazy.SitePermissions.setForPrincipal(
+            principal,
+            this.permissionKey,
+            promptAction.action,
+            scope
+          );
+        },
+      };
+      popupNotificationActions.push(action);
+    }
+
+    // Post-prompt animation
+    if (!chromeWin.gReduceMotion) {
+      let anchor = chromeWin.document.getElementById(this.anchorID);
+      // Only show the animation on the first request, not after e.g. tab switching.
+      anchor.addEventListener(
+        "animationend",
+        () => anchor.removeAttribute("animate"),
+        { once: true }
+      );
+      anchor.setAttribute("animate", "true");
+    }
+
+    this.#showNotification(popupNotificationActions, true);
+  }
+
+  #showNotification(actions, postPrompt = false) {
+    let chromeWin = this.browser.ownerGlobal;
+    let mainAction = actions.length ? actions[0] : null;
+    let secondaryActions = actions.splice(1);
+
+    let options = this.popupOptions;
+
+    if (!options.hasOwnProperty("displayURI") || options.displayURI) {
+      options.displayURI = this.principal.URI;
+    }
+
+    if (!postPrompt) {
+      // Permission prompts are always persistent; the close button is controlled by a pref.
+      options.persistent = true;
+      options.hideClose = true;
+    }
+
+    options.eventCallback = (topic, nextRemovalReason, isCancel) => {
+      // When the docshell of the browser is aboout to be swapped to another one,
+      // the "swapping" event is called. Returning true causes the notification
+      // to be moved to the new browser.
+      if (topic == "swapping") {
+        return true;
+      }
+      // The prompt has been shown, notify the PermissionUI.
+      // onShown() is currently not called for post-prompts,
+      // because there is no prompt that would make use of this.
+      // You can remove this restriction if you need it, but be
+      // mindful of other consumers.
+      if (topic == "shown" && !postPrompt) {
+        this.onShown();
+      }
+      // The prompt has been removed, notify the PermissionUI.
+      // onAfterShow() is currently not called for post-prompts,
+      // because there is no prompt that would make use of this.
+      // You can remove this restriction if you need it, but be
+      // mindful of other consumers.
+      if (topic == "removed" && !postPrompt) {
+        if (isCancel) {
+          this.cancel();
+        }
+        this.onAfterShow();
+      }
+      return false;
+    };
+
+    // Post-prompts show up as dismissed.
+    options.dismissed = postPrompt;
+
+    // onBeforeShow() is currently not called for post-prompts,
+    // because there is no prompt that would make use of this.
+    // You can remove this restriction if you need it, but be
+    // mindful of other consumers.
+    if (postPrompt || this.onBeforeShow() !== false) {
+      chromeWin.PopupNotifications.show(
+        this.browser,
+        this.notificationID,
+        this.message,
+        this.anchorID,
+        mainAction,
+        secondaryActions,
+        options
+      );
+    }
+  }
+}
+
+/**
+ * A subclass of PermissionPrompt that assumes
+ * that this.request is an nsIContentPermissionRequest
+ * and fills in some of the required properties on the
+ * PermissionPrompt. For callers that are wrapping an
+ * nsIContentPermissionRequest, this should be subclassed
+ * rather than PermissionPrompt.
+ */
+class PermissionPromptForRequest extends PermissionPrompt {
+  get browser() {
+    // In the e10s-case, the <xul:browser> will be at request.element.
+    // In the single-process case, we have to use some XPCOM incantations
+    // to resolve to the <xul:browser>.
+    if (this.request.element) {
+      return this.request.element;
+    }
+    return this.request.window.docShell.chromeEventHandler;
+  }
+
+  get principal() {
+    let request = this.request.QueryInterface(Ci.nsIContentPermissionRequest);
+    return request.getDelegatePrincipal(this.type);
+  }
+
+  cancel() {
+    this.request.cancel();
+  }
+
+  allow(choices) {
+    this.request.allow(choices);
+  }
+}
+
+/**
+ * A subclass of PermissionPromptForRequest that prompts
+ * for a Synthetic SitePermsAddon addon type and starts a synthetic
+ * addon install flow.
+ */
+class SitePermsAddonInstallRequest extends PermissionPromptForRequest {
+  prompt() {
+    // fallback to regular permission prompt for localhost,
+    // or when the SitePermsAddonProvider is not enabled.
+    if (this.principal.isLoopbackHost || !lazy.sitePermsAddonsProviderEnabled) {
+      super.prompt();
+      return;
+    }
+
+    // Otherwise, we'll use the addon install flow.
+    lazy.AddonManager.installSitePermsAddonFromWebpage(
+      this.browser,
+      this.principal,
+      this.permName
+    ).then(
+      () => {
+        this.allow();
+      },
+      err => {
+        this.cancel();
+
+        // Print an error message in the console to give more information to the developer.
+        let scriptErrorClass = Cc["@mozilla.org/scripterror;1"];
+        let errorMessage =
+          this.getInstallErrorMessage(err) ||
+          `${this.permName} access was rejected: ${err.message}`;
+
+        let scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError);
+        scriptError.initWithWindowID(
+          errorMessage,
+          null,
+          null,
+          0,
+          0,
+          0,
+          "content javascript",
+          this.browser.browsingContext.currentWindowGlobal.innerWindowId
+        );
+        Services.console.logMessage(scriptError);
+      }
+    );
+  }
+
+  /**
+   * Returns an error message that will be printed to the console given a passed Component.Exception.
+   * This should be overriden by children classes.
+   *
+   * @param {Components.Exception} err
+   * @returns {String} The error message
+   */
+  getInstallErrorMessage(err) {
+    return null;
+  }
+}
+
+/**
+ * Creates a PermissionPrompt for a nsIContentPermissionRequest for
+ * the GeoLocation API.
+ *
+ * @param request (nsIContentPermissionRequest)
+ *        The request for a permission from content.
+ */
+class GeolocationPermissionPrompt extends PermissionPromptForRequest {
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+
+  get type() {
+    return "geo";
+  }
+
+  get permissionKey() {
+    return "geo";
+  }
+
+  get popupOptions() {
+    let pref = "browser.geolocation.warning.infoURL";
+    let options = {
+      learnMoreURL: Services.urlFormatter.formatURLPref(pref),
+      displayURI: false,
+      name: this.getPrincipalName(),
+    };
+
+    // Don't offer "always remember" action in PB mode
+    options.checkbox = {
+      show: !lazy.PrivateBrowsingUtils.isWindowPrivate(
+        this.browser.ownerGlobal
+      ),
+    };
+
+    if (this.request.isRequestDelegatedToUnsafeThirdParty) {
+      // Second name should be the third party origin
+      options.secondName = this.getPrincipalName(this.request.principal);
+      options.checkbox = { show: false };
+    }
+
+    if (options.checkbox.show) {
+      options.checkbox.label = lazy.gBrowserBundle.GetStringFromName(
+        "geolocation.remember"
+      );
+    }
+
+    return options;
+  }
+
+  get notificationID() {
+    return "geolocation";
+  }
+
+  get anchorID() {
+    return "geo-notification-icon";
+  }
+
+  get message() {
+    if (this.principal.schemeIs("file")) {
+      return lazy.gBrowserBundle.GetStringFromName(
+        "geolocation.shareWithFile4"
+      );
+    }
+
+    if (this.request.isRequestDelegatedToUnsafeThirdParty) {
+      return lazy.gBrowserBundle.formatStringFromName(
+        "geolocation.shareWithSiteUnsafeDelegation2",
+        ["<>", "{}"]
+      );
+    }
+
+    return lazy.gBrowserBundle.formatStringFromName(
+      "geolocation.shareWithSite4",
+      ["<>"]
+    );
+  }
+
+  get promptActions() {
+    return [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("geolocation.allow"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "geolocation.allow.accesskey"
+        ),
+        action: lazy.SitePermissions.ALLOW,
+      },
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("geolocation.block"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "geolocation.block.accesskey"
+        ),
+        action: lazy.SitePermissions.BLOCK,
+      },
+    ];
+  }
+
+  #updateGeoSharing(state) {
+    let gBrowser = this.browser.ownerGlobal.gBrowser;
+    if (gBrowser == null) {
+      return;
+    }
+    gBrowser.updateBrowserSharing(this.browser, { geo: state });
+
+    // Update last access timestamp
+    let host;
+    try {
+      host = this.browser.currentURI.host;
+    } catch (e) {
+      return;
+    }
+    if (host == null || host == "") {
+      return;
+    }
+    lazy.ContentPrefService2.set(
+      this.browser.currentURI.host,
+      "permissions.geoLocation.lastAccess",
+      new Date().toString(),
+      this.browser.loadContext
+    );
+  }
+
+  allow(...args) {
+    this.#updateGeoSharing(true);
+    super.allow(...args);
+  }
+
+  cancel(...args) {
+    this.#updateGeoSharing(false);
+    super.cancel(...args);
+  }
+}
+
+/**
+ * Creates a PermissionPrompt for a nsIContentPermissionRequest for
+ * the WebXR API.
+ *
+ * @param request (nsIContentPermissionRequest)
+ *        The request for a permission from content.
+ */
+class XRPermissionPrompt extends PermissionPromptForRequest {
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+
+  get type() {
+    return "xr";
+  }
+
+  get permissionKey() {
+    return "xr";
+  }
+
+  get popupOptions() {
+    let pref = "browser.xr.warning.infoURL";
+    let options = {
+      learnMoreURL: Services.urlFormatter.formatURLPref(pref),
+      displayURI: false,
+      name: this.getPrincipalName(),
+    };
+
+    // Don't offer "always remember" action in PB mode
+    options.checkbox = {
+      show: !lazy.PrivateBrowsingUtils.isWindowPrivate(
+        this.browser.ownerGlobal
+      ),
+    };
+
+    if (options.checkbox.show) {
+      options.checkbox.label =
+        lazy.gBrowserBundle.GetStringFromName("xr.remember");
+    }
+
+    return options;
+  }
+
+  get notificationID() {
+    return "xr";
+  }
+
+  get anchorID() {
+    return "xr-notification-icon";
+  }
+
+  get message() {
+    if (this.principal.schemeIs("file")) {
+      return lazy.gBrowserBundle.GetStringFromName("xr.shareWithFile4");
+    }
+
+    return lazy.gBrowserBundle.formatStringFromName("xr.shareWithSite4", [
+      "<>",
+    ]);
+  }
+
+  get promptActions() {
+    return [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("xr.allow2"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName("xr.allow2.accesskey"),
+        action: lazy.SitePermissions.ALLOW,
+      },
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("xr.block"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName("xr.block.accesskey"),
+        action: lazy.SitePermissions.BLOCK,
+      },
+    ];
+  }
+
+  #updateXRSharing(state) {
+    let gBrowser = this.browser.ownerGlobal.gBrowser;
+    if (gBrowser == null) {
+      return;
+    }
+    gBrowser.updateBrowserSharing(this.browser, { xr: state });
+
+    let devicePermOrigins = this.browser.getDevicePermissionOrigins("xr");
+    if (!state) {
+      devicePermOrigins.delete(this.principal.origin);
+      return;
+    }
+    devicePermOrigins.add(this.principal.origin);
+  }
+
+  allow(...args) {
+    this.#updateXRSharing(true);
+    super.allow(...args);
+  }
+
+  cancel(...args) {
+    this.#updateXRSharing(false);
+    super.cancel(...args);
+  }
+}
+
+/**
+ * Creates a PermissionPrompt for a nsIContentPermissionRequest for
+ * the Desktop Notification API.
+ *
+ * @param request (nsIContentPermissionRequest)
+ *        The request for a permission from content.
+ * @return {PermissionPrompt} (see documentation in header)
+ */
+class DesktopNotificationPermissionPrompt extends PermissionPromptForRequest {
+  constructor(request) {
+    super();
+    this.request = request;
+
+    XPCOMUtils.defineLazyPreferenceGetter(
+      this,
+      "requiresUserInput",
+      "dom.webnotifications.requireuserinteraction"
+    );
+    XPCOMUtils.defineLazyPreferenceGetter(
+      this,
+      "postPromptEnabled",
+      "permissions.desktop-notification.postPrompt.enabled"
+    );
+    XPCOMUtils.defineLazyPreferenceGetter(
+      this,
+      "notNowEnabled",
+      "permissions.desktop-notification.notNow.enabled"
+    );
+  }
+
+  get type() {
+    return "desktop-notification";
+  }
+
+  get permissionKey() {
+    return "desktop-notification";
+  }
+
+  get popupOptions() {
+    let learnMoreURL =
+      Services.urlFormatter.formatURLPref("app.support.baseURL") + "push";
+
+    return {
+      learnMoreURL,
+      displayURI: false,
+      name: this.getPrincipalName(),
+    };
+  }
+
+  get notificationID() {
+    return "web-notifications";
+  }
+
+  get anchorID() {
+    return "web-notifications-notification-icon";
+  }
+
+  get message() {
+    return lazy.gBrowserBundle.formatStringFromName(
+      "webNotifications.receiveFromSite3",
+      ["<>"]
+    );
+  }
+
+  get promptActions() {
+    let actions = [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("webNotifications.allow2"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "webNotifications.allow2.accesskey"
+        ),
+        action: lazy.SitePermissions.ALLOW,
+        scope: lazy.SitePermissions.SCOPE_PERSISTENT,
+      },
+    ];
+    if (this.notNowEnabled) {
+      actions.push({
+        label: lazy.gBrowserBundle.GetStringFromName("webNotifications.notNow"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "webNotifications.notNow.accesskey"
+        ),
+        action: lazy.SitePermissions.BLOCK,
+      });
+    }
+
+    let isBrowserPrivate = lazy.PrivateBrowsingUtils.isBrowserPrivate(
+      this.browser
+    );
+    actions.push({
+      label: isBrowserPrivate
+        ? lazy.gBrowserBundle.GetStringFromName("webNotifications.block")
+        : lazy.gBrowserBundle.GetStringFromName("webNotifications.alwaysBlock"),
+      accessKey: isBrowserPrivate
+        ? lazy.gBrowserBundle.GetStringFromName(
+            "webNotifications.block.accesskey"
+          )
+        : lazy.gBrowserBundle.GetStringFromName(
+            "webNotifications.alwaysBlock.accesskey"
+          ),
+      action: lazy.SitePermissions.BLOCK,
+      scope: isBrowserPrivate
+        ? lazy.SitePermissions.SCOPE_SESSION
+        : lazy.SitePermissions.SCOPE_PERSISTENT,
+    });
+    return actions;
+  }
+
+  get postPromptActions() {
+    let actions = [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("webNotifications.allow2"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "webNotifications.allow2.accesskey"
+        ),
+        action: lazy.SitePermissions.ALLOW,
+      },
+    ];
+
+    let isBrowserPrivate = lazy.PrivateBrowsingUtils.isBrowserPrivate(
+      this.browser
+    );
+    actions.push({
+      label: isBrowserPrivate
+        ? lazy.gBrowserBundle.GetStringFromName("webNotifications.block")
+        : lazy.gBrowserBundle.GetStringFromName("webNotifications.alwaysBlock"),
+      accessKey: isBrowserPrivate
+        ? lazy.gBrowserBundle.GetStringFromName(
+            "webNotifications.block.accesskey"
+          )
+        : lazy.gBrowserBundle.GetStringFromName(
+            "webNotifications.alwaysBlock.accesskey"
+          ),
+      action: lazy.SitePermissions.BLOCK,
+    });
+    return actions;
+  }
+}
+
+/**
+ * Creates a PermissionPrompt for a nsIContentPermissionRequest for
+ * the persistent-storage API.
+ *
+ * @param request (nsIContentPermissionRequest)
+ *        The request for a permission from content.
+ */
+class PersistentStoragePermissionPrompt extends PermissionPromptForRequest {
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+
+  get type() {
+    return "persistent-storage";
+  }
+
+  get permissionKey() {
+    return "persistent-storage";
+  }
+
+  get popupOptions() {
+    let learnMoreURL =
+      Services.urlFormatter.formatURLPref("app.support.baseURL") +
+      "storage-permissions";
+    return {
+      learnMoreURL,
+      displayURI: false,
+      name: this.getPrincipalName(),
+    };
+  }
+
+  get notificationID() {
+    return "persistent-storage";
+  }
+
+  get anchorID() {
+    return "persistent-storage-notification-icon";
+  }
+
+  get message() {
+    return lazy.gBrowserBundle.formatStringFromName(
+      "persistentStorage.allowWithSite2",
+      ["<>"]
+    );
+  }
+
+  get promptActions() {
+    return [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("persistentStorage.allow"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "persistentStorage.allow.accesskey"
+        ),
+        action: Ci.nsIPermissionManager.ALLOW_ACTION,
+        scope: lazy.SitePermissions.SCOPE_PERSISTENT,
+      },
+      {
+        label: lazy.gBrowserBundle.GetStringFromName(
+          "persistentStorage.block.label"
+        ),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "persistentStorage.block.accesskey"
+        ),
+        action: lazy.SitePermissions.BLOCK,
+      },
+    ];
+  }
+}
+
+/**
+ * Creates a PermissionPrompt for a nsIContentPermissionRequest for
+ * the WebMIDI API.
+ *
+ * @param request (nsIContentPermissionRequest)
+ *        The request for a permission from content.
+ */
+class MIDIPermissionPrompt extends SitePermsAddonInstallRequest {
+  constructor(request) {
+    super();
+    this.request = request;
+    let types = request.types.QueryInterface(Ci.nsIArray);
+    let perm = types.queryElementAt(0, Ci.nsIContentPermissionType);
+    this.isSysexPerm =
+      !!perm.options.length &&
+      perm.options.queryElementAt(0, Ci.nsISupportsString) == "sysex";
+    this.permName = "midi";
+    if (this.isSysexPerm) {
+      this.permName = "midi-sysex";
+    }
+  }
+
+  get type() {
+    return "midi";
+  }
+
+  get permissionKey() {
+    return this.permName;
+  }
+
+  get popupOptions() {
+    // TODO (bug 1433235) We need a security/permissions explanation URL for this
+    let options = {
+      displayURI: false,
+      name: this.getPrincipalName(),
+    };
+
+    // Don't offer "always remember" action in PB mode
+    options.checkbox = {
+      show: !lazy.PrivateBrowsingUtils.isWindowPrivate(
+        this.browser.ownerGlobal
+      ),
+    };
+
+    if (options.checkbox.show) {
+      options.checkbox.label =
+        lazy.gBrowserBundle.GetStringFromName("midi.remember");
+    }
+
+    return options;
+  }
+
+  get notificationID() {
+    return "midi";
+  }
+
+  get anchorID() {
+    return "midi-notification-icon";
+  }
+
+  get message() {
+    let message;
+    if (this.principal.schemeIs("file")) {
+      if (this.isSysexPerm) {
+        message = lazy.gBrowserBundle.GetStringFromName(
+          "midi.shareSysexWithFile"
+        );
+      } else {
+        message = lazy.gBrowserBundle.GetStringFromName("midi.shareWithFile");
+      }
+    } else if (this.isSysexPerm) {
+      message = lazy.gBrowserBundle.formatStringFromName(
+        "midi.shareSysexWithSite",
+        ["<>"]
+      );
+    } else {
+      message = lazy.gBrowserBundle.formatStringFromName("midi.shareWithSite", [
+        "<>",
+      ]);
+    }
+    return message;
+  }
+
+  get promptActions() {
+    return [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("midi.allow.label"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "midi.allow.accesskey"
+        ),
+        action: Ci.nsIPermissionManager.ALLOW_ACTION,
+      },
+      {
+        label: lazy.gBrowserBundle.GetStringFromName("midi.block.label"),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "midi.block.accesskey"
+        ),
+        action: Ci.nsIPermissionManager.DENY_ACTION,
+      },
+    ];
+  }
+
+  /**
+   * @override
+   * @param {Components.Exception} err
+   * @returns {String}
+   */
+  getInstallErrorMessage(err) {
+    return `WebMIDI access request was denied: ❝${err.message}❞. See https://developer.mozilla.org/docs/Web/API/Navigator/requestMIDIAccess for more information`;
+  }
+}
+
+class StorageAccessPermissionPrompt extends PermissionPromptForRequest {
+  #permissionKey;
+
+  constructor(request) {
+    super();
+    this.request = request;
+    this.siteOption = null;
+    this.#permissionKey = `3rdPartyStorage${lazy.SitePermissions.PERM_KEY_DELIMITER}${this.principal.origin}`;
+
+    let types = this.request.types.QueryInterface(Ci.nsIArray);
+    let perm = types.queryElementAt(0, Ci.nsIContentPermissionType);
+    let options = perm.options.QueryInterface(Ci.nsIArray);
+    // If we have an option, the permission request is different in some way.
+    // We may be in a call from requestStorageAccessUnderSite or a frame-scoped
+    // request, which means that the embedding principal is not the current top-level
+    // or the permission key is different.
+    if (options.length != 2) {
+      return;
+    }
+
+    let topLevelOption = options.queryElementAt(0, Ci.nsISupportsString).data;
+    if (topLevelOption) {
+      this.siteOption = topLevelOption;
+    }
+    let frameOption = options.queryElementAt(1, Ci.nsISupportsString).data;
+    if (frameOption) {
+      // We replace the permission key with a frame-specific one that only has a site after the delimiter
+      this.#permissionKey = `3rdPartyFrameStorage${lazy.SitePermissions.PERM_KEY_DELIMITER}${this.principal.siteOrigin}`;
+    }
+  }
+
+  get usePermissionManager() {
+    return false;
+  }
+
+  get type() {
+    return "storage-access";
+  }
+
+  get permissionKey() {
+    // Make sure this name is unique per each third-party tracker
+    return this.#permissionKey;
+  }
+
+  get temporaryPermissionURI() {
+    if (this.siteOption) {
+      return Services.io.newURI(this.siteOption);
+    }
+    return undefined;
+  }
+
+  prettifyHostPort(hostport) {
+    let [host, port] = hostport.split(":");
+    host = lazy.IDNService.convertToDisplayIDN(host, {});
+    if (port) {
+      return `${host}:${port}`;
+    }
+    return host;
+  }
+
+  get popupOptions() {
+    let learnMoreURL =
+      Services.urlFormatter.formatURLPref("app.support.baseURL") +
+      "third-party-cookies";
+    let hostPort = this.prettifyHostPort(this.principal.hostPort);
+    let hintText = lazy.gBrowserBundle.formatStringFromName(
+      "storageAccess1.hintText",
+      [hostPort]
+    );
+    return {
+      learnMoreURL,
+      displayURI: false,
+      hintText,
+      escAction: "secondarybuttoncommand",
+    };
+  }
+
+  get notificationID() {
+    return "storage-access";
+  }
+
+  get anchorID() {
+    return "storage-access-notification-icon";
+  }
+
+  get message() {
+    let embeddingHost = this.topLevelPrincipal.host;
+
+    if (this.siteOption) {
+      embeddingHost = this.siteOption.split("://").at(-1);
+    }
+
+    return lazy.gBrowserBundle.formatStringFromName("storageAccess4.message", [
+      this.prettifyHostPort(this.principal.hostPort),
+      this.prettifyHostPort(embeddingHost),
+    ]);
+  }
+
+  get promptActions() {
+    let self = this;
+
+    return [
+      {
+        label: lazy.gBrowserBundle.GetStringFromName(
+          "storageAccess1.Allow.label"
+        ),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "storageAccess1.Allow.accesskey"
+        ),
+        action: Ci.nsIPermissionManager.ALLOW_ACTION,
+        callback(state) {
+          self.allow({ "storage-access": "allow" });
+        },
+      },
+      {
+        label: lazy.gBrowserBundle.GetStringFromName(
+          "storageAccess1.DontAllow.label"
+        ),
+        accessKey: lazy.gBrowserBundle.GetStringFromName(
+          "storageAccess1.DontAllow.accesskey"
+        ),
+        action: Ci.nsIPermissionManager.DENY_ACTION,
+        callback(state) {
+          self.cancel();
+        },
+      },
+    ];
+  }
+
+  get topLevelPrincipal() {
+    return this.request.topLevelPrincipal;
+  }
+}
+
+export const PermissionUI = {
+  PermissionPromptForRequest,
+  GeolocationPermissionPrompt,
+  XRPermissionPrompt,
+  DesktopNotificationPermissionPrompt,
+  PersistentStoragePermissionPrompt,
+  MIDIPermissionPrompt,
+  StorageAccessPermissionPrompt,
+};
diff --git a/browser/modules/ProcessHangMonitor.sys.mjs b/browser/modules/ProcessHangMonitor.sys.mjs
new file mode 100644
index 0000000000..f0939449c9
--- /dev/null
+++ b/browser/modules/ProcessHangMonitor.sys.mjs
@@ -0,0 +1,692 @@
+/* -*- mode: js; indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+/**
+ * Elides the middle of a string by replacing it with an elipsis if it is
+ * longer than `threshold` characters. Does its best to not break up grapheme
+ * clusters.
+ */
+function elideMiddleOfString(str, threshold) {
+  const searchDistance = 5;
+  const stubLength = threshold / 2 - searchDistance;
+  if (str.length <= threshold || stubLength < searchDistance) {
+    return str;
+  }
+
+  function searchElisionPoint(position) {
+    let unsplittableCharacter = c => /[\p{M}\uDC00-\uDFFF]/u.test(c);
+    for (let i = 0; i < searchDistance; i++) {
+      if (!unsplittableCharacter(str[position + i])) {
+        return position + i;
+      }
+
+      if (!unsplittableCharacter(str[position - i])) {
+        return position - i;
+      }
+    }
+    return position;
+  }
+
+  let elisionStart = searchElisionPoint(stubLength);
+  let elisionEnd = searchElisionPoint(str.length - stubLength);
+  if (elisionStart < elisionEnd) {
+    str = str.slice(0, elisionStart) + "\u2026" + str.slice(elisionEnd);
+  }
+  return str;
+}
+
+/**
+ * This JSM is responsible for observing content process hang reports
+ * and asking the user what to do about them. See nsIHangReport for
+ * the platform interface.
+ */
+
+export var ProcessHangMonitor = {
+  /**
+   * This timeout is the wait period applied after a user selects "Wait" in
+   * an existing notification.
+   */
+  get WAIT_EXPIRATION_TIME() {
+    try {
+      return Services.prefs.getIntPref("browser.hangNotification.waitPeriod");
+    } catch (ex) {
+      return 10000;
+    }
+  },
+
+  /**
+   * Should only be set to true once the quit-application-granted notification
+   * has been fired.
+   */
+  _shuttingDown: false,
+
+  /**
+   * Collection of hang reports that haven't expired or been dismissed
+   * by the user. These are nsIHangReports. They are mapped to objects
+   * containing:
+   * - notificationTime: when (Cu.now()) we first showed a notification
+   * - waitCount: how often the user asked to wait for the script to finish
+   * - lastReportFromChild: when (Cu.now()) we last got hang info from the
+   *   child.
+   */
+  _activeReports: new Map(),
+
+  /**
+   * Collection of hang reports that have been suppressed for a short
+   * period of time. Value is an object like in _activeReports, but also
+   * including a `timer` prop, which is an nsITimer for when the wait time
+   * expires.
+   */
+  _pausedReports: new Map(),
+
+  /**
+   * Initialize hang reporting. Called once in the parent process.
+   */
+  init() {
+    Services.obs.addObserver(this, "process-hang-report");
+    Services.obs.addObserver(this, "clear-hang-report");
+    Services.obs.addObserver(this, "quit-application-granted");
+    Services.obs.addObserver(this, "xpcom-shutdown");
+    Services.ww.registerNotification(this);
+    Services.telemetry.setEventRecordingEnabled("slow_script_warning", true);
+  },
+
+  /**
+   * Terminate JavaScript associated with the hang being reported for
+   * the selected browser in |win|.
+   */
+  terminateScript(win) {
+    this.handleUserInput(win, report => report.terminateScript());
+  },
+
+  /**
+   * Start devtools debugger for JavaScript associated with the hang
+   * being reported for the selected browser in |win|.
+   */
+  debugScript(win) {
+    this.handleUserInput(win, report => {
+      function callback() {
+        report.endStartingDebugger();
+      }
+
+      this._recordTelemetryForReport(report, "debugging");
+      report.beginStartingDebugger();
+
+      let svc = Cc["@mozilla.org/dom/slow-script-debug;1"].getService(
+        Ci.nsISlowScriptDebug
+      );
+      let handler = svc.remoteActivationHandler;
+      handler.handleSlowScriptDebug(report.scriptBrowser, callback);
+    });
+  },
+
+  /**
+   * Dismiss the browser notification and invoke an appropriate action based on
+   * the hang type.
+   */
+  stopIt(win) {
+    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
+    if (!report) {
+      return;
+    }
+
+    this._recordTelemetryForReport(report, "user-aborted");
+    this.terminateScript(win);
+  },
+
+  /**
+   * Terminate the script causing this report. This is done without
+   * updating any report notifications.
+   */
+  stopHang(report, endReason, backupInfo) {
+    this._recordTelemetryForReport(report, endReason, backupInfo);
+    report.terminateScript();
+  },
+
+  /**
+   * Dismiss the notification, clear the report from the active list and set up
+   * a new timer to track a wait period during which we won't notify.
+   */
+  waitLonger(win) {
+    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
+    if (!report) {
+      return;
+    }
+    // Update the other info we keep.
+    let reportInfo = this._activeReports.get(report);
+    reportInfo.waitCount++;
+
+    // Remove the report from the active list.
+    this.removeActiveReport(report);
+
+    // NOTE, we didn't call userCanceled on nsIHangReport here. This insures
+    // we don't repeatedly generate and cache crash report data for this hang
+    // in the process hang reporter. It already has one report for the browser
+    // process we want it hold onto.
+
+    // Create a new wait timer with notify callback
+    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    timer.initWithCallback(
+      () => {
+        for (let [stashedReport, pausedInfo] of this._pausedReports) {
+          if (pausedInfo.timer === timer) {
+            this.removePausedReport(stashedReport);
+
+            // We're still hung, so move the report back to the active
+            // list and update the UI.
+            this._activeReports.set(report, pausedInfo);
+            this.updateWindows();
+            break;
+          }
+        }
+      },
+      this.WAIT_EXPIRATION_TIME,
+      timer.TYPE_ONE_SHOT
+    );
+
+    reportInfo.timer = timer;
+    this._pausedReports.set(report, reportInfo);
+
+    // remove the browser notification associated with this hang
+    this.updateWindows();
+  },
+
+  /**
+   * If there is a hang report associated with the selected browser in
+   * |win|, invoke |func| on that report and stop notifying the user
+   * about it.
+   */
+  handleUserInput(win, func) {
+    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
+    if (!report) {
+      return null;
+    }
+    this.removeActiveReport(report);
+
+    return func(report);
+  },
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case "xpcom-shutdown": {
+        Services.obs.removeObserver(this, "xpcom-shutdown");
+        Services.obs.removeObserver(this, "process-hang-report");
+        Services.obs.removeObserver(this, "clear-hang-report");
+        Services.obs.removeObserver(this, "quit-application-granted");
+        Services.ww.unregisterNotification(this);
+        break;
+      }
+
+      case "quit-application-granted": {
+        this.onQuitApplicationGranted();
+        break;
+      }
+
+      case "process-hang-report": {
+        this.reportHang(subject.QueryInterface(Ci.nsIHangReport));
+        break;
+      }
+
+      case "clear-hang-report": {
+        this.clearHang(subject.QueryInterface(Ci.nsIHangReport));
+        break;
+      }
+
+      case "domwindowopened": {
+        // Install event listeners on the new window in case one of
+        // its tabs is already hung.
+        let win = subject;
+        let listener = ev => {
+          win.removeEventListener("load", listener, true);
+          this.updateWindows();
+        };
+        win.addEventListener("load", listener, true);
+        break;
+      }
+
+      case "domwindowclosed": {
+        let win = subject;
+        this.onWindowClosed(win);
+        break;
+      }
+    }
+  },
+
+  /**
+   * Called early on in the shutdown sequence. We take this opportunity to
+   * take any pre-existing hang reports, and terminate them. We also put
+   * ourselves in a state so that if any more hang reports show up while
+   * we're shutting down, we terminate them immediately.
+   */
+  onQuitApplicationGranted() {
+    this._shuttingDown = true;
+    this.stopAllHangs("quit-application-granted");
+    this.updateWindows();
+  },
+
+  onWindowClosed(win) {
+    let maybeStopHang = report => {
+      let hungBrowserWindow = null;
+      try {
+        hungBrowserWindow = report.scriptBrowser.ownerGlobal;
+      } catch (e) {
+        // Ignore failures to get the script browser - we'll be
+        // conservative, and assume that if we cannot access the
+        // window that belongs to this report that we should stop
+        // the hang.
+      }
+      if (!hungBrowserWindow || hungBrowserWindow == win) {
+        this.stopHang(report, "window-closed");
+        return true;
+      }
+      return false;
+    };
+
+    // If there are any script hangs for browsers that are in this window
+    // that is closing, we can stop them now.
+    for (let [report] of this._activeReports) {
+      if (maybeStopHang(report)) {
+        this._activeReports.delete(report);
+      }
+    }
+
+    for (let [pausedReport] of this._pausedReports) {
+      if (maybeStopHang(pausedReport)) {
+        this.removePausedReport(pausedReport);
+      }
+    }
+
+    this.updateWindows();
+  },
+
+  stopAllHangs(endReason) {
+    for (let [report] of this._activeReports) {
+      this.stopHang(report, endReason);
+    }
+
+    this._activeReports = new Map();
+
+    for (let [pausedReport] of this._pausedReports) {
+      this.stopHang(pausedReport, endReason);
+      this.removePausedReport(pausedReport);
+    }
+  },
+
+  /**
+   * Find a active hang report for the given <browser> element.
+   */
+  findActiveReport(browser) {
+    let frameLoader = browser.frameLoader;
+    for (let report of this._activeReports.keys()) {
+      if (report.isReportForBrowserOrChildren(frameLoader)) {
+        return report;
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Find a paused hang report for the given <browser> element.
+   */
+  findPausedReport(browser) {
+    let frameLoader = browser.frameLoader;
+    for (let [report] of this._pausedReports) {
+      if (report.isReportForBrowserOrChildren(frameLoader)) {
+        return report;
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Tell telemetry about the report.
+   */
+  _recordTelemetryForReport(report, endReason, backupInfo) {
+    let info =
+      this._activeReports.get(report) ||
+      this._pausedReports.get(report) ||
+      backupInfo;
+    if (!info) {
+      return;
+    }
+    try {
+      let uri_type;
+      if (report.addonId) {
+        uri_type = "extension";
+      } else if (report.scriptFileName?.startsWith("debugger")) {
+        uri_type = "devtools";
+      } else {
+        try {
+          let url = new URL(report.scriptFileName);
+          if (url.protocol == "chrome:" || url.protocol == "resource:") {
+            uri_type = "browser";
+          } else {
+            uri_type = "content";
+          }
+        } catch (ex) {
+          console.error(ex);
+          uri_type = "unknown";
+        }
+      }
+      let uptime = 0;
+      if (info.notificationTime) {
+        uptime = Cu.now() - info.notificationTime;
+      }
+      uptime = "" + uptime;
+      // We combine the duration of the hang in the content process with the
+      // time since we were last told about the hang in the parent. This is
+      // not the same as the time we showed a notification, as we only do that
+      // for the currently selected browser. It's as messy as it is because
+      // there is no cross-process monotonically increasing timestamp we can
+      // use. :-(
+      let hangDuration =
+        report.hangDuration + Cu.now() - info.lastReportFromChild;
+      Services.telemetry.recordEvent(
+        "slow_script_warning",
+        "shown",
+        "content",
+        null,
+        {
+          end_reason: endReason,
+          hang_duration: "" + hangDuration,
+          n_tab_deselect: "" + info.deselectCount,
+          uri_type,
+          uptime,
+          wait_count: "" + info.waitCount,
+        }
+      );
+    } catch (ex) {
+      console.error(ex);
+    }
+  },
+
+  /**
+   * Remove an active hang report from the active list and cancel the timer
+   * associated with it.
+   */
+  removeActiveReport(report) {
+    this._activeReports.delete(report);
+    this.updateWindows();
+  },
+
+  /**
+   * Remove a paused hang report from the paused list and cancel the timer
+   * associated with it.
+   */
+  removePausedReport(report) {
+    let info = this._pausedReports.get(report);
+    info?.timer?.cancel();
+    this._pausedReports.delete(report);
+  },
+
+  /**
+   * Iterate over all XUL windows and ensure that the proper hang
+   * reports are shown for each one. Also install event handlers in
+   * each window to watch for events that would cause a different hang
+   * report to be displayed.
+   */
+  updateWindows() {
+    let e = Services.wm.getEnumerator("navigator:browser");
+
+    // If it turns out we have no windows (this can happen on macOS),
+    // we have no opportunity to ask the user whether or not they want
+    // to stop the hang or wait, so we'll opt for stopping the hang.
+    if (!e.hasMoreElements()) {
+      this.stopAllHangs("no-windows-left");
+      return;
+    }
+
+    for (let win of e) {
+      this.updateWindow(win);
+
+      // Only listen for these events if there are active hang reports.
+      if (this._activeReports.size) {
+        this.trackWindow(win);
+      } else {
+        this.untrackWindow(win);
+      }
+    }
+  },
+
+  /**
+   * If there is a hang report for the current tab in |win|, display it.
+   */
+  updateWindow(win) {
+    let report = this.findActiveReport(win.gBrowser.selectedBrowser);
+
+    if (report) {
+      let info = this._activeReports.get(report);
+      if (info && !info.notificationTime) {
+        info.notificationTime = Cu.now();
+      }
+      this.showNotification(win, report);
+    } else {
+      this.hideNotification(win);
+    }
+  },
+
+  /**
+   * Show the notification for a hang.
+   */
+  async showNotification(win, report) {
+    let bundle = win.gNavigatorBundle;
+
+    let buttons = [
+      {
+        label: bundle.getString("processHang.button_stop2.label"),
+        accessKey: bundle.getString("processHang.button_stop2.accessKey"),
+        callback() {
+          ProcessHangMonitor.stopIt(win);
+        },
+      },
+    ];
+
+    let message;
+    let doc = win.document;
+    let brandShortName = doc
+      .getElementById("bundle_brand")
+      .getString("brandShortName");
+    let notificationTag;
+    if (report.addonId) {
+      notificationTag = report.addonId;
+      let aps = Cc["@mozilla.org/addons/policy-service;1"].getService(
+        Ci.nsIAddonPolicyService
+      );
+
+      let addonName = aps.getExtensionName(report.addonId);
+
+      message = bundle.getFormattedString("processHang.add-on.label2", [
+        addonName,
+        brandShortName,
+      ]);
+
+      buttons.unshift({
+        label: bundle.getString("processHang.add-on.learn-more.text"),
+        link: "https://support.mozilla.org/kb/warning-unresponsive-script#w_other-causes",
+      });
+    } else {
+      let scriptBrowser = report.scriptBrowser;
+      if (scriptBrowser == win.gBrowser?.selectedBrowser) {
+        notificationTag = "selected-tab";
+        message = bundle.getFormattedString("processHang.selected_tab.label", [
+          brandShortName,
+        ]);
+      } else {
+        let tab =
+          scriptBrowser?.ownerGlobal.gBrowser?.getTabForBrowser(scriptBrowser);
+        if (!tab) {
+          notificationTag = "nonspecific_tab";
+          message = bundle.getFormattedString(
+            "processHang.nonspecific_tab.label",
+            [brandShortName]
+          );
+        } else {
+          notificationTag = scriptBrowser.browserId.toString();
+          let title = tab.getAttribute("label");
+          title = elideMiddleOfString(title, 60);
+          message = bundle.getFormattedString(
+            "processHang.specific_tab.label",
+            [title, brandShortName]
+          );
+        }
+      }
+    }
+
+    let notification =
+      win.gNotificationBox.getNotificationWithValue("process-hang");
+    if (notificationTag == notification?.getAttribute("notification-tag")) {
+      return;
+    }
+
+    if (notification) {
+      notification.label = message;
+      notification.setAttribute("notification-tag", notificationTag);
+      return;
+    }
+
+    // Show the "debug script" button unconditionally if we are in Developer edition,
+    // or, if DevTools are opened on the slow tab.
+    if (
+      AppConstants.MOZ_DEV_EDITION ||
+      report.scriptBrowser.browsingContext.watchedByDevTools
+    ) {
+      buttons.push({
+        label: bundle.getString("processHang.button_debug.label"),
+        accessKey: bundle.getString("processHang.button_debug.accessKey"),
+        callback() {
+          ProcessHangMonitor.debugScript(win);
+        },
+      });
+    }
+
+    // Sometimes the window may have closed already, in which case we won't
+    // be able to create a message bar so we need to handle any related errors.
+    try {
+      let hangNotification = await win.gNotificationBox.appendNotification(
+        "process-hang",
+        {
+          label: message,
+          image: "chrome://browser/content/aboutRobots-icon.png",
+          priority: win.gNotificationBox.PRIORITY_INFO_HIGH,
+          eventCallback: event => {
+            if (event == "dismissed") {
+              ProcessHangMonitor.waitLonger(win);
+            }
+          },
+        },
+        buttons
+      );
+      hangNotification.setAttribute("notification-tag", notificationTag);
+    } catch (err) {
+      console.warn(err);
+    }
+  },
+
+  /**
+   * Ensure that no hang notifications are visible in |win|.
+   */
+  hideNotification(win) {
+    let notification =
+      win.gNotificationBox.getNotificationWithValue("process-hang");
+    if (notification) {
+      win.gNotificationBox.removeNotification(notification);
+    }
+  },
+
+  /**
+   * Install event handlers on |win| to watch for events that would
+   * cause a different hang report to be displayed.
+   */
+  trackWindow(win) {
+    win.gBrowser.tabContainer.addEventListener("TabSelect", this, true);
+    win.gBrowser.tabContainer.addEventListener(
+      "TabRemotenessChange",
+      this,
+      true
+    );
+  },
+
+  untrackWindow(win) {
+    win.gBrowser.tabContainer.removeEventListener("TabSelect", this, true);
+    win.gBrowser.tabContainer.removeEventListener(
+      "TabRemotenessChange",
+      this,
+      true
+    );
+  },
+
+  handleEvent(event) {
+    let win = event.target.ownerGlobal;
+
+    // If a new tab is selected or if a tab changes remoteness, then
+    // we may need to show or hide a hang notification.
+    if (event.type == "TabSelect" || event.type == "TabRemotenessChange") {
+      if (event.type == "TabSelect" && event.detail.previousTab) {
+        // If we've got a notification, check the previous tab's report and
+        // indicate the user switched tabs while the notification was up.
+        let r =
+          this.findActiveReport(event.detail.previousTab.linkedBrowser) ||
+          this.findPausedReport(event.detail.previousTab.linkedBrowser);
+        if (r) {
+          let info = this._activeReports.get(r) || this._pausedReports.get(r);
+          info.deselectCount++;
+        }
+      }
+      this.updateWindow(win);
+    }
+  },
+
+  /**
+   * Handle a potentially new hang report. If it hasn't been seen
+   * before, show a notification for it in all open XUL windows.
+   */
+  reportHang(report) {
+    let now = Cu.now();
+    if (this._shuttingDown) {
+      this.stopHang(report, "shutdown-in-progress", {
+        lastReportFromChild: now,
+        waitCount: 0,
+        deselectCount: 0,
+      });
+      return;
+    }
+
+    // If this hang was already reported reset the timer for it.
+    if (this._activeReports.has(report)) {
+      this._activeReports.get(report).lastReportFromChild = now;
+      // if this report is in active but doesn't have a notification associated
+      // with it, display a notification.
+      this.updateWindows();
+      return;
+    }
+
+    // If this hang was already reported and paused by the user ignore it.
+    if (this._pausedReports.has(report)) {
+      this._pausedReports.get(report).lastReportFromChild = now;
+      return;
+    }
+
+    // On e10s this counts slow-script notice only once.
+    // This code is not reached on non-e10s.
+    Services.telemetry.getHistogramById("SLOW_SCRIPT_NOTICE_COUNT").add();
+
+    this._activeReports.set(report, {
+      deselectCount: 0,
+      lastReportFromChild: now,
+      waitCount: 0,
+    });
+    this.updateWindows();
+  },
+
+  clearHang(report) {
+    this._recordTelemetryForReport(report, "cleared");
+
+    this.removeActiveReport(report);
+    this.removePausedReport(report);
+    report.userCanceled();
+  },
+};
diff --git a/browser/modules/Sanitizer.sys.mjs b/browser/modules/Sanitizer.sys.mjs
new file mode 100644
index 0000000000..895cf6df83
--- /dev/null
+++ b/browser/modules/Sanitizer.sys.mjs
@@ -0,0 +1,1412 @@
+// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ContextualIdentityService:
+    "resource://gre/modules/ContextualIdentityService.sys.mjs",
+  FormHistory: "resource://gre/modules/FormHistory.sys.mjs",
+  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+  PrincipalsCollector: "resource://gre/modules/PrincipalsCollector.sys.mjs",
+});
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "useOldClearHistoryDialog",
+  "privacy.sanitize.useOldClearHistoryDialog",
+  false
+);
+
+var logConsole;
+function log(msg) {
+  if (!logConsole) {
+    logConsole = console.createInstance({
+      prefix: "** Sanitizer.jsm",
+      maxLogLevelPref: "browser.sanitizer.loglevel",
+    });
+  }
+
+  logConsole.log(msg);
+}
+
+// Used as unique id for pending sanitizations.
+var gPendingSanitizationSerial = 0;
+
+var gPrincipalsCollector = null;
+
+export var Sanitizer = {
+  /**
+   * Whether we should sanitize on shutdown.
+   */
+  PREF_SANITIZE_ON_SHUTDOWN: "privacy.sanitize.sanitizeOnShutdown",
+
+  /**
+   * During a sanitization this is set to a JSON containing an array of the
+   * pending sanitizations. This allows to retry sanitizations on startup in
+   * case they dind't run or were interrupted by a crash.
+   * Use addPendingSanitization and removePendingSanitization to manage it.
+   */
+  PREF_PENDING_SANITIZATIONS: "privacy.sanitize.pending",
+
+  /**
+   * Pref branches to fetch sanitization options from.
+   */
+  PREF_CPD_BRANCH: "privacy.cpd.",
+  PREF_SHUTDOWN_BRANCH: "privacy.clearOnShutdown.",
+  PREF_SHUTDOWN_V2_BRANCH: "privacy.clearOnShutdown_v2.",
+
+  /**
+   * The fallback timestamp used when no argument is given to
+   * Sanitizer.getClearRange.
+   */
+  PREF_TIMESPAN: "privacy.sanitize.timeSpan",
+
+  /**
+   * Pref to newTab segregation. If true, on shutdown, the private container
+   * used in about:newtab is cleaned up.  Exposed because used in tests.
+   */
+  PREF_NEWTAB_SEGREGATION:
+    "privacy.usercontext.about_newtab_segregation.enabled",
+
+  /**
+   * Time span constants corresponding to values of the privacy.sanitize.timeSpan
+   * pref.  Used to determine how much history to clear, for various items
+   */
+  TIMESPAN_EVERYTHING: 0,
+  TIMESPAN_HOUR: 1,
+  TIMESPAN_2HOURS: 2,
+  TIMESPAN_4HOURS: 3,
+  TIMESPAN_TODAY: 4,
+  TIMESPAN_5MIN: 5,
+  TIMESPAN_24HOURS: 6,
+
+  /**
+   * Mapping time span constants to get total time in ms from the selected
+   * time spans
+   */
+  timeSpanMsMap: {
+    TIMESPAN_5MIN: 300000, // 5*60*1000
+    TIMESPAN_HOUR: 3600000, // 60*60*1000
+    TIMESPAN_2HOURS: 7200000, // 2*60*60*1000
+    TIMESPAN_4HOURS: 14400000, // 4*60*60*1000
+    TIMESPAN_24HOURS: 86400000, // 24*60*60*1000
+    get TIMESPAN_TODAY() {
+      return Date.now() - new Date().setHours(0, 0, 0, 0);
+    }, // time spent today
+  },
+
+  /**
+   * Whether we should sanitize on shutdown.
+   * When this is set, a pending sanitization should also be added and removed
+   * when shutdown sanitization is complete. This allows to retry incomplete
+   * sanitizations on startup.
+   */
+  shouldSanitizeOnShutdown: false,
+
+  /**
+   * Whether we should sanitize the private container for about:newtab.
+   */
+  shouldSanitizeNewTabContainer: false,
+
+  /**
+   * Shows a sanitization dialog to the user. Returns after the dialog box has
+   * closed.
+   *
+   * @param parentWindow the browser window to use as parent for the created
+   *        dialog.
+   * @param {string} mode - flag to let the dialog know if it is opened
+   *        using the clear on shutdown (clearOnShutdown) settings option
+   *        in about:preferences or in a clear site data context (clearSiteData)
+   *
+   * @throws if parentWindow is undefined or doesn't have a gDialogBox.
+   */
+  showUI(parentWindow, mode) {
+    // Treat the hidden window as not being a parent window:
+    if (
+      parentWindow?.document.documentURI ==
+      "chrome://browser/content/hiddenWindowMac.xhtml"
+    ) {
+      parentWindow = null;
+    }
+
+    let dialogFile = lazy.useOldClearHistoryDialog
+      ? "sanitize.xhtml"
+      : "sanitize_v2.xhtml";
+
+    if (parentWindow?.gDialogBox) {
+      parentWindow.gDialogBox.open(`chrome://browser/content/${dialogFile}`, {
+        inBrowserWindow: true,
+        mode,
+      });
+    } else {
+      Services.ww.openWindow(
+        parentWindow,
+        `chrome://browser/content/${dialogFile}`,
+        "Sanitize",
+        "chrome,titlebar,dialog,centerscreen,modal",
+        { needNativeUI: true, mode }
+      );
+    }
+  },
+
+  /**
+   * Performs startup tasks:
+   *  - Checks if sanitizations were not completed during the last session.
+   *  - Registers sanitize-on-shutdown.
+   */
+  async onStartup() {
+    // First, collect pending sanitizations from the last session, before we
+    // add pending sanitizations for this session.
+    let pendingSanitizations = getAndClearPendingSanitizations();
+
+    // Check if we should sanitize on shutdown.
+    this.shouldSanitizeOnShutdown = Services.prefs.getBoolPref(
+      Sanitizer.PREF_SANITIZE_ON_SHUTDOWN,
+      false
+    );
+    Services.prefs.addObserver(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN, this, true);
+    // Add a pending shutdown sanitization, if necessary.
+    if (this.shouldSanitizeOnShutdown) {
+      let itemsToClear = getItemsToClearFromPrefBranch(
+        Sanitizer.PREF_SHUTDOWN_BRANCH
+      );
+      addPendingSanitization("shutdown", itemsToClear, {});
+    }
+    // Shutdown sanitization is always pending, but the user may change the
+    // sanitize on shutdown prefs during the session. Then the pending
+    // sanitization would become stale and must be updated.
+    Services.prefs.addObserver(Sanitizer.PREF_SHUTDOWN_BRANCH, this, true);
+
+    // Make sure that we are triggered during shutdown.
+    let shutdownClient = lazy.PlacesUtils.history.shutdownClient.jsclient;
+    // We need to pass to sanitize() (through sanitizeOnShutdown) a state object
+    // that tracks the status of the shutdown blocker. This `progress` object
+    // will be updated during sanitization and reported with the crash in case of
+    // a shutdown timeout.
+    // We use the `options` argument to pass the `progress` object to sanitize().
+    let progress = { isShutdown: true, clearHonoringExceptions: true };
+    shutdownClient.addBlocker(
+      "sanitize.js: Sanitize on shutdown",
+      () => sanitizeOnShutdown(progress),
+      { fetchState: () => ({ progress }) }
+    );
+
+    this.shouldSanitizeNewTabContainer = Services.prefs.getBoolPref(
+      this.PREF_NEWTAB_SEGREGATION,
+      false
+    );
+    if (this.shouldSanitizeNewTabContainer) {
+      addPendingSanitization("newtab-container", [], {});
+    }
+
+    let i = pendingSanitizations.findIndex(s => s.id == "newtab-container");
+    if (i != -1) {
+      pendingSanitizations.splice(i, 1);
+      sanitizeNewTabSegregation();
+    }
+
+    // Finally, run the sanitizations that were left pending, because we crashed
+    // before completing them.
+    for (let { itemsToClear, options } of pendingSanitizations) {
+      try {
+        // We need to set this flag to watch out for the users exceptions like we do on shutdown
+        options.progress = { clearHonoringExceptions: true };
+        await this.sanitize(itemsToClear, options);
+      } catch (ex) {
+        console.error(
+          "A previously pending sanitization failed: ",
+          itemsToClear,
+          ex
+        );
+      }
+    }
+  },
+
+  /**
+   * Returns a 2 element array representing the start and end times,
+   * in the uSec-since-epoch format that PRTime likes. If we should
+   * clear everything, this function returns null.
+   *
+   * @param ts [optional] a timespan to convert to start and end time.
+   *                      Falls back to the privacy.sanitize.timeSpan preference
+   *                      if this argument is omitted.
+   *                      If this argument is provided, it has to be one of the
+   *                      Sanitizer.TIMESPAN_* constants. This function will
+   *                      throw an error otherwise.
+   *
+   * @return {Array} a 2-element Array containing the start and end times.
+   */
+  getClearRange(ts) {
+    if (ts === undefined) {
+      ts = Services.prefs.getIntPref(Sanitizer.PREF_TIMESPAN);
+    }
+    if (ts === Sanitizer.TIMESPAN_EVERYTHING) {
+      return null;
+    }
+
+    // PRTime is microseconds while JS time is milliseconds
+    var endDate = Date.now() * 1000;
+    switch (ts) {
+      case Sanitizer.TIMESPAN_5MIN:
+        var startDate = endDate - 300000000; // 5*60*1000000
+        break;
+      case Sanitizer.TIMESPAN_HOUR:
+        startDate = endDate - 3600000000; // 1*60*60*1000000
+        break;
+      case Sanitizer.TIMESPAN_2HOURS:
+        startDate = endDate - 7200000000; // 2*60*60*1000000
+        break;
+      case Sanitizer.TIMESPAN_4HOURS:
+        startDate = endDate - 14400000000; // 4*60*60*1000000
+        break;
+      case Sanitizer.TIMESPAN_TODAY:
+        var d = new Date(); // Start with today
+        d.setHours(0); // zero us back to midnight...
+        d.setMinutes(0);
+        d.setSeconds(0);
+        d.setMilliseconds(0);
+        startDate = d.valueOf() * 1000; // convert to epoch usec
+        break;
+      case Sanitizer.TIMESPAN_24HOURS:
+        startDate = endDate - 86400000000; // 24*60*60*1000000
+        break;
+      default:
+        throw new Error("Invalid time span for clear private data: " + ts);
+    }
+    return [startDate, endDate];
+  },
+
+  /**
+   * Deletes privacy sensitive data in a batch, according to user preferences.
+   * Returns a promise which is resolved if no errors occurred.  If an error
+   * occurs, a message is reported to the console and all other items are still
+   * cleared before the promise is finally rejected.
+   *
+   * @param [optional] itemsToClear
+   *        Array of items to be cleared. if specified only those
+   *        items get cleared, irrespectively of the preference settings.
+   * @param [optional] options
+   *        Object whose properties are options for this sanitization:
+   *         - ignoreTimespan (default: true): Time span only makes sense in
+   *           certain cases.  Consumers who want to only clear some private
+   *           data can opt in by setting this to false, and can optionally
+   *           specify a specific range.
+   *           If timespan is not ignored, and range is not set, sanitize() will
+   *           use the value of the timespan pref to determine a range.
+   *         - range (default: null): array-tuple of [from, to] timestamps
+   *         - privateStateForNewWindow (default: "non-private"): when clearing
+   *           open windows, defines the private state for the newly opened window.
+   * @returns {object} An object containing debug information about the
+   *          sanitization progress. This state object is also used as
+   *          AsyncShutdown metadata.
+   */
+  async sanitize(itemsToClear = null, options = {}) {
+    let progress = options.progress;
+    // initialise the principals collector
+    gPrincipalsCollector = new lazy.PrincipalsCollector();
+    if (!progress) {
+      progress = options.progress = {};
+    }
+
+    if (!itemsToClear) {
+      itemsToClear = getItemsToClearFromPrefBranch(this.PREF_CPD_BRANCH);
+    }
+    let promise = sanitizeInternal(this.items, itemsToClear, options);
+
+    // Depending on preferences, the sanitizer may perform asynchronous
+    // work before it starts cleaning up the Places database (e.g. closing
+    // windows). We need to make sure that the connection to that database
+    // hasn't been closed by the time we use it.
+    // Though, if this is a sanitize on shutdown, we already have a blocker.
+    if (!progress.isShutdown) {
+      let shutdownClient = lazy.PlacesUtils.history.shutdownClient.jsclient;
+      shutdownClient.addBlocker("sanitize.js: Sanitize", promise, {
+        fetchState: () => ({ progress }),
+      });
+    }
+
+    try {
+      await promise;
+    } finally {
+      Services.obs.notifyObservers(null, "sanitizer-sanitization-complete");
+    }
+    return progress;
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "nsPref:changed") {
+      if (
+        data.startsWith(this.PREF_SHUTDOWN_BRANCH) &&
+        this.shouldSanitizeOnShutdown
+      ) {
+        // Update the pending shutdown sanitization.
+        removePendingSanitization("shutdown");
+        let itemsToClear = getItemsToClearFromPrefBranch(
+          Sanitizer.PREF_SHUTDOWN_BRANCH
+        );
+        addPendingSanitization("shutdown", itemsToClear, {});
+      } else if (data == this.PREF_SANITIZE_ON_SHUTDOWN) {
+        this.shouldSanitizeOnShutdown = Services.prefs.getBoolPref(
+          Sanitizer.PREF_SANITIZE_ON_SHUTDOWN,
+          false
+        );
+        removePendingSanitization("shutdown");
+        if (this.shouldSanitizeOnShutdown) {
+          let itemsToClear = getItemsToClearFromPrefBranch(
+            Sanitizer.PREF_SHUTDOWN_BRANCH
+          );
+          addPendingSanitization("shutdown", itemsToClear, {});
+        }
+      } else if (data == this.PREF_NEWTAB_SEGREGATION) {
+        this.shouldSanitizeNewTabContainer = Services.prefs.getBoolPref(
+          this.PREF_NEWTAB_SEGREGATION,
+          false
+        );
+        removePendingSanitization("newtab-container");
+        if (this.shouldSanitizeNewTabContainer) {
+          addPendingSanitization("newtab-container", [], {});
+        }
+      }
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIObserver",
+    "nsISupportsWeakReference",
+  ]),
+
+  // This method is meant to be used by tests.
+  async runSanitizeOnShutdown() {
+    // The collector needs to be reset for each test, as the collection only happens
+    // once and does not update after that.
+    // Pretend that it has never been initialized to mimic the actual browser behavior
+    // by setting it to null.
+    // The actually initialization will happen either via sanitize() or directly in
+    // sanitizeOnShutdown.
+    gPrincipalsCollector = null;
+    return sanitizeOnShutdown({
+      isShutdown: true,
+      clearHonoringExceptions: true,
+    });
+  },
+
+  /**
+   * Migrate old sanitize on shutdown prefs to the new prefs for the new
+   * clear on shutdown dialog. Does nothing if the migration was completed before
+   * based on the pref privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs
+   *
+   */
+  maybeMigrateSanitizeOnShutdownPrefs() {
+    if (
+      Services.prefs.getBoolPref(
+        "privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs"
+      )
+    ) {
+      return;
+    }
+
+    let cookies = Services.prefs.getBoolPref("privacy.clearOnShutdown.cookies");
+    let history = Services.prefs.getBoolPref("privacy.clearOnShutdown.history");
+    let cache = Services.prefs.getBoolPref("privacy.clearOnShutdown.cache");
+    let siteSettings = Services.prefs.getBoolPref(
+      "privacy.clearOnShutdown.siteSettings"
+    );
+
+    // We set cookiesAndStorage to true if cookies are enabled for clearing on shutdown
+    // regardless of what sessions and offlineApps are set to
+    // This is because cookie clearing behaviour takes precedence over sessions and offlineApps clearing.
+    Services.prefs.setBoolPref(
+      "privacy.clearOnShutdown_v2.cookiesAndStorage",
+      cookies
+    );
+
+    // we set historyFormDataAndDownloads to true if history is enabled for clearing on
+    // shutdown, regardless of what form data is set to.
+    // This is because history clearing behavious takes precedence over formdata clearing.
+    Services.prefs.setBoolPref(
+      "privacy.clearOnShutdown_v2.historyFormDataAndDownloads",
+      history
+    );
+
+    // cache and siteSettings follow the old dialog prefs
+    Services.prefs.setBoolPref("privacy.clearOnShutdown_v2.cache", cache);
+
+    Services.prefs.setBoolPref(
+      "privacy.clearOnShutdown_v2.siteSettings",
+      siteSettings
+    );
+
+    Services.prefs.setBoolPref(
+      "privacy.sanitize.sanitizeOnShutdown.hasMigratedToNewPrefs",
+      true
+    );
+  },
+
+  // When making any changes to the sanitize implementations here,
+  // please check whether the changes are applicable to Android
+  // (mobile/android/modules/geckoview/GeckoViewStorageController.jsm) as well.
+
+  items: {
+    cache: {
+      async clear(range) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_CACHE", refObj);
+        await clearData(range, Ci.nsIClearDataService.CLEAR_ALL_CACHES);
+        TelemetryStopwatch.finish("FX_SANITIZE_CACHE", refObj);
+      },
+    },
+
+    cookies: {
+      async clear(range, { progress }, clearHonoringExceptions) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_COOKIES_2", refObj);
+        // This is true if called by sanitizeOnShutdown.
+        // On shutdown we clear by principal to be able to honor the users exceptions
+        if (clearHonoringExceptions) {
+          progress.step = "getAllPrincipals";
+          let principalsForShutdownClearing =
+            await gPrincipalsCollector.getAllPrincipals(progress);
+          await maybeSanitizeSessionPrincipals(
+            progress,
+            principalsForShutdownClearing,
+            Ci.nsIClearDataService.CLEAR_COOKIES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
+              Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
+          );
+        } else {
+          // Not on shutdown
+          await clearData(
+            range,
+            Ci.nsIClearDataService.CLEAR_COOKIES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
+              Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
+          );
+        }
+        await clearData(range, Ci.nsIClearDataService.CLEAR_MEDIA_DEVICES);
+        TelemetryStopwatch.finish("FX_SANITIZE_COOKIES_2", refObj);
+      },
+    },
+
+    offlineApps: {
+      async clear(range, { progress }, clearHonoringExceptions) {
+        // This is true if called by sanitizeOnShutdown.
+        // On shutdown we clear by principal to be able to honor the users exceptions
+        if (clearHonoringExceptions) {
+          progress.step = "getAllPrincipals";
+          let principalsForShutdownClearing =
+            await gPrincipalsCollector.getAllPrincipals(progress);
+          await maybeSanitizeSessionPrincipals(
+            progress,
+            principalsForShutdownClearing,
+            Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
+          );
+        } else {
+          // Not on shutdown
+          await clearData(
+            range,
+            Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
+          );
+        }
+      },
+    },
+
+    history: {
+      async clear(range, { progress }) {
+        // TODO: This check is needed for the case that this method is invoked directly and not via the sanitizer.sanitize API.
+        // This can be removed once bug 1803799 has landed.
+        if (!gPrincipalsCollector) {
+          gPrincipalsCollector = new lazy.PrincipalsCollector();
+        }
+        progress.step = "getAllPrincipals";
+        let principals = await gPrincipalsCollector.getAllPrincipals(progress);
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_HISTORY", refObj);
+        progress.step = "clearing browsing history";
+        await clearData(
+          range,
+          Ci.nsIClearDataService.CLEAR_HISTORY |
+            Ci.nsIClearDataService.CLEAR_SESSION_HISTORY |
+            Ci.nsIClearDataService.CLEAR_CONTENT_BLOCKING_RECORDS
+        );
+
+        // storageAccessAPI permissions record every site that the user
+        // interacted with and thus mirror history quite closely. It makes
+        // sense to clear them when we clear history. However, since their absence
+        // indicates that we can purge cookies and site data for tracking origins without
+        // user interaction, we need to ensure that we only delete those permissions that
+        // do not have any existing storage.
+        progress.step = "clearing user interaction";
+        await new Promise(resolve => {
+          Services.clearData.deleteUserInteractionForClearingHistory(
+            principals,
+            range ? range[0] : 0,
+            resolve
+          );
+        });
+        TelemetryStopwatch.finish("FX_SANITIZE_HISTORY", refObj);
+      },
+    },
+
+    formdata: {
+      async clear(range) {
+        let seenException;
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_FORMDATA", refObj);
+        try {
+          // Clear undo history of all search bars.
+          for (let currentWindow of Services.wm.getEnumerator(
+            "navigator:browser"
+          )) {
+            let currentDocument = currentWindow.document;
+
+            // searchBar may not exist if it's in the customize mode.
+            let searchBar = currentDocument.getElementById("searchbar");
+            if (searchBar) {
+              let input = searchBar.textbox;
+              input.value = "";
+              input.editor?.clearUndoRedo();
+            }
+
+            let tabBrowser = currentWindow.gBrowser;
+            if (!tabBrowser) {
+              // No tab browser? This means that it's too early during startup (typically,
+              // Session Restore hasn't completed yet). Since we don't have find
+              // bars at that stage and since Session Restore will not restore
+              // find bars further down during startup, we have nothing to clear.
+              continue;
+            }
+            for (let tab of tabBrowser.tabs) {
+              if (tabBrowser.isFindBarInitialized(tab)) {
+                tabBrowser.getCachedFindBar(tab).clear();
+              }
+            }
+            // Clear any saved find value
+            tabBrowser._lastFindValue = "";
+          }
+        } catch (ex) {
+          seenException = ex;
+        }
+
+        try {
+          let change = { op: "remove" };
+          if (range) {
+            [change.firstUsedStart, change.firstUsedEnd] = range;
+          }
+          await lazy.FormHistory.update(change).catch(e => {
+            seenException = new Error("Error " + e.result + ": " + e.message);
+          });
+        } catch (ex) {
+          seenException = ex;
+        }
+
+        TelemetryStopwatch.finish("FX_SANITIZE_FORMDATA", refObj);
+        if (seenException) {
+          throw seenException;
+        }
+      },
+    },
+
+    downloads: {
+      async clear(range) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_DOWNLOADS", refObj);
+        await clearData(range, Ci.nsIClearDataService.CLEAR_DOWNLOADS);
+        TelemetryStopwatch.finish("FX_SANITIZE_DOWNLOADS", refObj);
+      },
+    },
+
+    sessions: {
+      async clear(range) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_SESSIONS", refObj);
+        await clearData(
+          range,
+          Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
+            Ci.nsIClearDataService.CLEAR_AUTH_CACHE
+        );
+        TelemetryStopwatch.finish("FX_SANITIZE_SESSIONS", refObj);
+      },
+    },
+
+    siteSettings: {
+      async clear(range) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_SITESETTINGS", refObj);
+        await clearData(
+          range,
+          Ci.nsIClearDataService.CLEAR_PERMISSIONS |
+            Ci.nsIClearDataService.CLEAR_CONTENT_PREFERENCES |
+            Ci.nsIClearDataService.CLEAR_DOM_PUSH_NOTIFICATIONS |
+            Ci.nsIClearDataService.CLEAR_CLIENT_AUTH_REMEMBER_SERVICE |
+            Ci.nsIClearDataService.CLEAR_CERT_EXCEPTIONS |
+            Ci.nsIClearDataService.CLEAR_CREDENTIAL_MANAGER_STATE |
+            Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION |
+            Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE
+        );
+        TelemetryStopwatch.finish("FX_SANITIZE_SITESETTINGS", refObj);
+      },
+    },
+
+    openWindows: {
+      _canCloseWindow(win) {
+        if (win.CanCloseWindow()) {
+          // We already showed PermitUnload for the window, so let's
+          // make sure we don't do it again when we actually close the
+          // window.
+          win.skipNextCanClose = true;
+          return true;
+        }
+        return false;
+      },
+      _resetAllWindowClosures(windowList) {
+        for (let win of windowList) {
+          win.skipNextCanClose = false;
+        }
+      },
+      async clear(range, { privateStateForNewWindow = "non-private" }) {
+        // NB: this closes all *browser* windows, not other windows like the library, about window,
+        // browser console, etc.
+
+        // Keep track of the time in case we get stuck in la-la-land because of onbeforeunload
+        // dialogs
+        let startDate = Date.now();
+
+        // First check if all these windows are OK with being closed:
+        let windowList = [];
+        for (let someWin of Services.wm.getEnumerator("navigator:browser")) {
+          windowList.push(someWin);
+          // If someone says "no" to a beforeunload prompt, we abort here:
+          if (!this._canCloseWindow(someWin)) {
+            this._resetAllWindowClosures(windowList);
+            throw new Error(
+              "Sanitize could not close windows: cancelled by user"
+            );
+          }
+
+          // ...however, beforeunload prompts spin the event loop, and so the code here won't get
+          // hit until the prompt has been dismissed. If more than 1 minute has elapsed since we
+          // started prompting, stop, because the user might not even remember initiating the
+          // 'forget', and the timespans will be all wrong by now anyway:
+          if (Date.now() > startDate + 60 * 1000) {
+            this._resetAllWindowClosures(windowList);
+            throw new Error("Sanitize could not close windows: timeout");
+          }
+        }
+
+        if (!windowList.length) {
+          return;
+        }
+
+        // If/once we get here, we should actually be able to close all windows.
+
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_OPENWINDOWS", refObj);
+
+        // First create a new window. We do this first so that on non-mac, we don't
+        // accidentally close the app by closing all the windows.
+        let handler = Cc["@mozilla.org/browser/clh;1"].getService(
+          Ci.nsIBrowserHandler
+        );
+        let defaultArgs = handler.defaultArgs;
+        let features = "chrome,all,dialog=no," + privateStateForNewWindow;
+        let newWindow = windowList[0].openDialog(
+          AppConstants.BROWSER_CHROME_URL,
+          "_blank",
+          features,
+          defaultArgs
+        );
+
+        let onFullScreen = null;
+        if (AppConstants.platform == "macosx") {
+          onFullScreen = function (e) {
+            newWindow.removeEventListener("fullscreen", onFullScreen);
+            let docEl = newWindow.document.documentElement;
+            let sizemode = docEl.getAttribute("sizemode");
+            if (!newWindow.fullScreen && sizemode == "fullscreen") {
+              docEl.setAttribute("sizemode", "normal");
+              e.preventDefault();
+              e.stopPropagation();
+              return false;
+            }
+            return undefined;
+          };
+          newWindow.addEventListener("fullscreen", onFullScreen);
+        }
+
+        let promiseReady = new Promise(resolve => {
+          // Window creation and destruction is asynchronous. We need to wait
+          // until all existing windows are fully closed, and the new window is
+          // fully open, before continuing. Otherwise the rest of the sanitizer
+          // could run too early (and miss new cookies being set when a page
+          // closes) and/or run too late (and not have a fully-formed window yet
+          // in existence). See bug 1088137.
+          let newWindowOpened = false;
+          let onWindowOpened = function (subject, topic, data) {
+            if (subject != newWindow) {
+              return;
+            }
+
+            Services.obs.removeObserver(
+              onWindowOpened,
+              "browser-delayed-startup-finished"
+            );
+            if (AppConstants.platform == "macosx") {
+              newWindow.removeEventListener("fullscreen", onFullScreen);
+            }
+            newWindowOpened = true;
+            // If we're the last thing to happen, invoke callback.
+            if (numWindowsClosing == 0) {
+              TelemetryStopwatch.finish("FX_SANITIZE_OPENWINDOWS", refObj);
+              resolve();
+            }
+          };
+
+          let numWindowsClosing = windowList.length;
+          let onWindowClosed = function () {
+            numWindowsClosing--;
+            if (numWindowsClosing == 0) {
+              Services.obs.removeObserver(
+                onWindowClosed,
+                "xul-window-destroyed"
+              );
+              // If we're the last thing to happen, invoke callback.
+              if (newWindowOpened) {
+                TelemetryStopwatch.finish("FX_SANITIZE_OPENWINDOWS", refObj);
+                resolve();
+              }
+            }
+          };
+          Services.obs.addObserver(
+            onWindowOpened,
+            "browser-delayed-startup-finished"
+          );
+          Services.obs.addObserver(onWindowClosed, "xul-window-destroyed");
+        });
+
+        // Start the process of closing windows
+        while (windowList.length) {
+          windowList.pop().close();
+        }
+        newWindow.focus();
+        await promiseReady;
+      },
+    },
+
+    pluginData: {
+      async clear(range) {},
+    },
+
+    // Combine History and Form Data clearing for the
+    // new clear history dialog box.
+    historyFormDataAndDownloads: {
+      async clear(range, { progress }) {
+        progress.step = "getAllPrincipals";
+        let principals = await gPrincipalsCollector.getAllPrincipals(progress);
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_HISTORY", refObj);
+        progress.step = "clearing browsing history";
+        await clearData(
+          range,
+          Ci.nsIClearDataService.CLEAR_HISTORY |
+            Ci.nsIClearDataService.CLEAR_SESSION_HISTORY |
+            Ci.nsIClearDataService.CLEAR_CONTENT_BLOCKING_RECORDS
+        );
+
+        // storageAccessAPI permissions record every site that the user
+        // interacted with and thus mirror history quite closely. It makes
+        // sense to clear them when we clear history. However, since their absence
+        // indicates that we can purge cookies and site data for tracking origins without
+        // user interaction, we need to ensure that we only delete those permissions that
+        // do not have any existing storage.
+        progress.step = "clearing user interaction";
+        await new Promise(resolve => {
+          Services.clearData.deleteUserInteractionForClearingHistory(
+            principals,
+            range ? range[0] : 0,
+            resolve
+          );
+        });
+        TelemetryStopwatch.finish("FX_SANITIZE_HISTORY", refObj);
+
+        // Clear form data
+        let seenException;
+        refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_FORMDATA", refObj);
+        try {
+          // Clear undo history of all search bars.
+          for (let currentWindow of Services.wm.getEnumerator(
+            "navigator:browser"
+          )) {
+            let currentDocument = currentWindow.document;
+
+            // searchBar may not exist if it's in the customize mode.
+            let searchBar = currentDocument.getElementById("searchbar");
+            if (searchBar) {
+              let input = searchBar.textbox;
+              input.value = "";
+              input.editor?.clearUndoRedo();
+            }
+
+            let tabBrowser = currentWindow.gBrowser;
+            if (!tabBrowser) {
+              // No tab browser? This means that it's too early during startup (typically,
+              // Session Restore hasn't completed yet). Since we don't have find
+              // bars at that stage and since Session Restore will not restore
+              // find bars further down during startup, we have nothing to clear.
+              continue;
+            }
+            for (let tab of tabBrowser.tabs) {
+              if (tabBrowser.isFindBarInitialized(tab)) {
+                tabBrowser.getCachedFindBar(tab).clear();
+              }
+            }
+            // Clear any saved find value
+            tabBrowser._lastFindValue = "";
+          }
+        } catch (ex) {
+          seenException = ex;
+        }
+
+        try {
+          let change = { op: "remove" };
+          if (range) {
+            [change.firstUsedStart, change.firstUsedEnd] = range;
+          }
+          await lazy.FormHistory.update(change).catch(e => {
+            seenException = new Error("Error " + e.result + ": " + e.message);
+          });
+        } catch (ex) {
+          seenException = ex;
+        }
+
+        TelemetryStopwatch.finish("FX_SANITIZE_FORMDATA", refObj);
+        if (seenException) {
+          throw seenException;
+        }
+
+        // clear Downloads
+        refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_DOWNLOADS", refObj);
+        await clearData(range, Ci.nsIClearDataService.CLEAR_DOWNLOADS);
+        TelemetryStopwatch.finish("FX_SANITIZE_DOWNLOADS", refObj);
+      },
+    },
+
+    cookiesAndStorage: {
+      async clear(range, { progress }, clearHonoringExceptions) {
+        let refObj = {};
+        TelemetryStopwatch.start("FX_SANITIZE_COOKIES_2", refObj);
+        // This is true if called by sanitizeOnShutdown.
+        // On shutdown we clear by principal to be able to honor the users exceptions
+        if (clearHonoringExceptions) {
+          progress.step = "getAllPrincipals";
+          let principalsForShutdownClearing =
+            await gPrincipalsCollector.getAllPrincipals(progress);
+          await maybeSanitizeSessionPrincipals(
+            progress,
+            principalsForShutdownClearing,
+            Ci.nsIClearDataService.CLEAR_COOKIES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+              Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
+              Ci.nsIClearDataService.CLEAR_AUTH_CACHE |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
+              Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
+          );
+        } else {
+          // Not on shutdown
+          await clearData(
+            range,
+            Ci.nsIClearDataService.CLEAR_COOKIES |
+              Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+              Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+              Ci.nsIClearDataService.CLEAR_AUTH_TOKENS |
+              Ci.nsIClearDataService.CLEAR_AUTH_CACHE |
+              Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
+              Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
+          );
+        }
+        await clearData(range, Ci.nsIClearDataService.CLEAR_MEDIA_DEVICES);
+        TelemetryStopwatch.finish("FX_SANITIZE_COOKIES_2", refObj);
+      },
+    },
+  },
+};
+
+async function sanitizeInternal(items, aItemsToClear, options) {
+  let { ignoreTimespan = true, range, progress } = options;
+  let seenError = false;
+  // Shallow copy the array, as we are going to modify it in place later.
+  if (!Array.isArray(aItemsToClear)) {
+    throw new Error("Must pass an array of items to clear.");
+  }
+  let itemsToClear = [...aItemsToClear];
+
+  // Store the list of items to clear, in case we are killed before we
+  // get a chance to complete.
+  let uid = gPendingSanitizationSerial++;
+  // Shutdown sanitization is managed outside.
+  if (!progress.isShutdown) {
+    addPendingSanitization(uid, itemsToClear, options);
+  }
+
+  // Store the list of items to clear, for debugging/forensics purposes
+  for (let k of itemsToClear) {
+    progress[k] = "ready";
+    // Create a progress object specific to each cleaner. We'll pass down this
+    // to the cleaners instead of the main progress object, so they don't end
+    // up overriding properties each other.
+    // This specific progress is deleted if the cleaner completes successfully,
+    // so the metadata will only contain progress of unresolved cleaners.
+    progress[k + "Progress"] = {};
+  }
+
+  // Ensure open windows get cleared first, if they're in our list, so that
+  // they don't stick around in the recently closed windows list, and so we
+  // can cancel the whole thing if the user selects to keep a window open
+  // from a beforeunload prompt.
+  let openWindowsIndex = itemsToClear.indexOf("openWindows");
+  if (openWindowsIndex != -1) {
+    itemsToClear.splice(openWindowsIndex, 1);
+    await items.openWindows.clear(
+      null,
+      Object.assign(options, { progress: progress.openWindowsProgress })
+    );
+    progress.openWindows = "cleared";
+    delete progress.openWindowsProgress;
+  }
+
+  // If we ignore timespan, clear everything,
+  // otherwise, pick a range.
+  if (!ignoreTimespan && !range) {
+    range = Sanitizer.getClearRange();
+  }
+
+  // For performance reasons we start all the clear tasks at once, then wait
+  // for their promises later.
+  // Some of the clear() calls may raise exceptions (for example bug 265028),
+  // we catch and store them, but continue to sanitize as much as possible.
+  // Callers should check returned errors and give user feedback
+  // about items that could not be sanitized
+  let refObj = {};
+  TelemetryStopwatch.start("FX_SANITIZE_TOTAL", refObj);
+
+  let annotateError = (name, ex) => {
+    progress[name] = "failed";
+    seenError = true;
+    console.error("Error sanitizing " + name, ex);
+  };
+
+  // Array of objects in form { name, promise }.
+  // `name` is the item's name and `promise` may be a promise, if the
+  // sanitization is asynchronous, or the function return value, otherwise.
+  let handles = [];
+  for (let name of itemsToClear) {
+    progress[name] = "blocking";
+    let item = items[name];
+    try {
+      // Catch errors here, so later we can just loop through these.
+      handles.push({
+        name,
+        promise: item
+          .clear(
+            range,
+            Object.assign(options, { progress: progress[name + "Progress"] }),
+            progress.clearHonoringExceptions
+          )
+          .then(
+            () => {
+              progress[name] = "cleared";
+              delete progress[name + "Progress"];
+            },
+            ex => annotateError(name, ex)
+          ),
+      });
+    } catch (ex) {
+      annotateError(name, ex);
+    }
+  }
+  await Promise.all(handles.map(h => h.promise));
+
+  // Sanitization is complete.
+  TelemetryStopwatch.finish("FX_SANITIZE_TOTAL", refObj);
+  if (!progress.isShutdown) {
+    removePendingSanitization(uid);
+  }
+  progress = {};
+  if (seenError) {
+    throw new Error("Error sanitizing");
+  }
+}
+
+async function sanitizeOnShutdown(progress) {
+  log("Sanitizing on shutdown");
+  if (lazy.useOldClearHistoryDialog) {
+    progress.sanitizationPrefs = {
+      privacy_sanitize_sanitizeOnShutdown: Services.prefs.getBoolPref(
+        "privacy.sanitize.sanitizeOnShutdown"
+      ),
+      privacy_clearOnShutdown_cookies: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.cookies"
+      ),
+      privacy_clearOnShutdown_history: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.history"
+      ),
+      privacy_clearOnShutdown_formdata: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.formdata"
+      ),
+      privacy_clearOnShutdown_downloads: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.downloads"
+      ),
+      privacy_clearOnShutdown_cache: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.cache"
+      ),
+      privacy_clearOnShutdown_sessions: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.sessions"
+      ),
+      privacy_clearOnShutdown_offlineApps: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.offlineApps"
+      ),
+      privacy_clearOnShutdown_siteSettings: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.siteSettings"
+      ),
+      privacy_clearOnShutdown_openWindows: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown.openWindows"
+      ),
+    };
+  } else {
+    // Perform a migration if this is the first time sanitizeOnShutdown is
+    // running for the user with the new dialog
+    Sanitizer.maybeMigrateSanitizeOnShutdownPrefs();
+
+    progress.sanitizationPrefs = {
+      privacy_sanitize_sanitizeOnShutdown: Services.prefs.getBoolPref(
+        "privacy.sanitize.sanitizeOnShutdown"
+      ),
+      privacy_clearOnShutdown_v2_cookiesAndStorage: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown_v2.cookiesAndStorage"
+      ),
+      privacy_clearOnShutdown_v2_historyFormDataAndDownloads:
+        Services.prefs.getBoolPref(
+          "privacy.clearOnShutdown_v2.historyFormDataAndDownloads"
+        ),
+      privacy_clearOnShutdown_v2_cache: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown_v2.cache"
+      ),
+      privacy_clearOnShutdown_v2_siteSettings: Services.prefs.getBoolPref(
+        "privacy.clearOnShutdown_v2.siteSettings"
+      ),
+    };
+  }
+
+  let needsSyncSavePrefs = false;
+  if (Sanitizer.shouldSanitizeOnShutdown) {
+    // Need to sanitize upon shutdown
+    progress.advancement = "shutdown-cleaner";
+    let shutdownBranch = lazy.useOldClearHistoryDialog
+      ? Sanitizer.PREF_SHUTDOWN_BRANCH
+      : Sanitizer.PREF_SHUTDOWN_V2_BRANCH;
+    let itemsToClear = getItemsToClearFromPrefBranch(shutdownBranch);
+    await Sanitizer.sanitize(itemsToClear, { progress });
+
+    // We didn't crash during shutdown sanitization, so annotate it to avoid
+    // sanitizing again on startup.
+    removePendingSanitization("shutdown");
+    needsSyncSavePrefs = true;
+  }
+
+  if (Sanitizer.shouldSanitizeNewTabContainer) {
+    progress.advancement = "newtab-segregation";
+    sanitizeNewTabSegregation();
+    removePendingSanitization("newtab-container");
+    needsSyncSavePrefs = true;
+  }
+
+  if (needsSyncSavePrefs) {
+    Services.prefs.savePrefFile(null);
+  }
+
+  if (!Sanitizer.shouldSanitizeOnShutdown) {
+    // In case the user has not activated sanitizeOnShutdown but has explicitely set exceptions
+    // to always clear particular origins, we clear those here
+
+    progress.advancement = "session-permission";
+
+    let exceptions = 0;
+    let selectedPrincipals = [];
+    // Let's see if we have to forget some particular site.
+    for (let permission of Services.perms.all) {
+      if (
+        permission.type != "cookie" ||
+        permission.capability != Ci.nsICookiePermission.ACCESS_SESSION
+      ) {
+        continue;
+      }
+
+      // We consider just permissions set for http, https and file URLs.
+      if (!isSupportedPrincipal(permission.principal)) {
+        continue;
+      }
+
+      log(
+        "Custom session cookie permission detected for: " +
+          permission.principal.asciiSpec
+      );
+      exceptions++;
+
+      // We use just the URI here, because permissions ignore OriginAttributes.
+      // The principalsCollector is lazy, this is computed only once
+      if (!gPrincipalsCollector) {
+        gPrincipalsCollector = new lazy.PrincipalsCollector();
+      }
+      let principals = await gPrincipalsCollector.getAllPrincipals(progress);
+      selectedPrincipals.push(
+        ...extractMatchingPrincipals(principals, permission.principal.host)
+      );
+    }
+    await maybeSanitizeSessionPrincipals(
+      progress,
+      selectedPrincipals,
+      Ci.nsIClearDataService.CLEAR_ALL_CACHES |
+        Ci.nsIClearDataService.CLEAR_COOKIES |
+        Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+        Ci.nsIClearDataService.CLEAR_EME |
+        Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE
+    );
+    progress.sanitizationPrefs.session_permission_exceptions = exceptions;
+  }
+  progress.advancement = "done";
+}
+
+// Extracts the principals matching matchUri as root domain.
+function extractMatchingPrincipals(principals, matchHost) {
+  return principals.filter(principal => {
+    return Services.eTLD.hasRootDomain(matchHost, principal.host);
+  });
+}
+
+/**  This method receives a list of principals and it checks if some of them or
+ * some of their sub-domain need to be sanitize.
+ * @param {Object} progress - Object to keep track of the sanitization progress, prefs and mode
+ * @param {nsIPrincipal[]} principals - The principals generated by the PrincipalsCollector
+ * @param {int} flags - The cleaning categories that need to be cleaned for the principals.
+ * @returns {Promise} - Resolves once the clearing of the principals to be cleared is done
+ */
+async function maybeSanitizeSessionPrincipals(progress, principals, flags) {
+  log("Sanitizing " + principals.length + " principals");
+
+  let promises = [];
+  let permissions = new Map();
+  Services.perms.getAllWithTypePrefix("cookie").forEach(perm => {
+    permissions.set(perm.principal.origin, perm);
+  });
+
+  principals.forEach(principal => {
+    progress.step = "checking-principal";
+    let cookieAllowed = cookiesAllowedForDomainOrSubDomain(
+      principal,
+      permissions
+    );
+    progress.step = "principal-checked:" + cookieAllowed;
+
+    if (!cookieAllowed) {
+      promises.push(sanitizeSessionPrincipal(progress, principal, flags));
+    }
+  });
+
+  progress.step = "promises:" + promises.length;
+  if (promises.length) {
+    await Promise.all(promises);
+    await new Promise(resolve =>
+      Services.clearData.cleanupAfterDeletionAtShutdown(flags, resolve)
+    );
+  }
+  progress.step = "promises resolved";
+}
+
+function cookiesAllowedForDomainOrSubDomain(principal, permissions) {
+  log("Checking principal: " + principal.asciiSpec);
+
+  // If we have the 'cookie' permission for this principal, let's return
+  // immediately.
+  let cookiePermission = checkIfCookiePermissionIsSet(principal);
+  if (cookiePermission != null) {
+    return cookiePermission;
+  }
+
+  for (let perm of permissions.values()) {
+    if (perm.type != "cookie") {
+      permissions.delete(perm.principal.origin);
+      continue;
+    }
+    // We consider just permissions set for http, https and file URLs.
+    if (!isSupportedPrincipal(perm.principal)) {
+      permissions.delete(perm.principal.origin);
+      continue;
+    }
+
+    // We don't care about scheme, port, and anything else.
+    if (Services.eTLD.hasRootDomain(perm.principal.host, principal.host)) {
+      log("Cookie check on principal: " + perm.principal.asciiSpec);
+      let rootDomainCookiePermission = checkIfCookiePermissionIsSet(
+        perm.principal
+      );
+      if (rootDomainCookiePermission != null) {
+        return rootDomainCookiePermission;
+      }
+    }
+  }
+
+  log("Cookie not allowed.");
+  return false;
+}
+
+/**
+ * Checks if a cookie permission is set for a given principal
+ * @returns {boolean} - true: cookie permission "ACCESS_ALLOW", false: cookie permission "ACCESS_DENY"/"ACCESS_SESSION"
+ * @returns {null} - No cookie permission is set for this principal
+ */
+function checkIfCookiePermissionIsSet(principal) {
+  let p = Services.perms.testPermissionFromPrincipal(principal, "cookie");
+
+  if (p == Ci.nsICookiePermission.ACCESS_ALLOW) {
+    log("Cookie allowed!");
+    return true;
+  }
+
+  if (
+    p == Ci.nsICookiePermission.ACCESS_DENY ||
+    p == Ci.nsICookiePermission.ACCESS_SESSION
+  ) {
+    log("Cookie denied or session!");
+    return false;
+  }
+  // This is an old profile with unsupported permission values
+  if (p != Ci.nsICookiePermission.ACCESS_DEFAULT) {
+    log("Not supported cookie permission: " + p);
+    return false;
+  }
+  return null;
+}
+
+async function sanitizeSessionPrincipal(progress, principal, flags) {
+  log("Sanitizing principal: " + principal.asciiSpec);
+
+  await new Promise(resolve => {
+    progress.sanitizePrincipal = "started";
+    Services.clearData.deleteDataFromPrincipal(
+      principal,
+      true /* user request */,
+      flags,
+      resolve
+    );
+  });
+  progress.sanitizePrincipal = "completed";
+}
+
+function sanitizeNewTabSegregation() {
+  let identity = lazy.ContextualIdentityService.getPrivateIdentity(
+    "userContextIdInternal.thumbnail"
+  );
+  if (identity) {
+    Services.clearData.deleteDataFromOriginAttributesPattern({
+      userContextId: identity.userContextId,
+    });
+  }
+}
+
+/**
+ * Gets an array of items to clear from the given pref branch.
+ * @param branch The pref branch to fetch.
+ * @return Array of items to clear
+ */
+function getItemsToClearFromPrefBranch(branch) {
+  branch = Services.prefs.getBranch(branch);
+  return Object.keys(Sanitizer.items).filter(itemName => {
+    try {
+      return branch.getBoolPref(itemName);
+    } catch (ex) {
+      return false;
+    }
+  });
+}
+
+/**
+ * These functions are used to track pending sanitization on the next startup
+ * in case of a crash before a sanitization could happen.
+ * @param id A unique id identifying the sanitization
+ * @param itemsToClear The items to clear
+ * @param options The Sanitize options
+ */
+function addPendingSanitization(id, itemsToClear, options) {
+  let pendingSanitizations = safeGetPendingSanitizations();
+  pendingSanitizations.push({ id, itemsToClear, options });
+  Services.prefs.setStringPref(
+    Sanitizer.PREF_PENDING_SANITIZATIONS,
+    JSON.stringify(pendingSanitizations)
+  );
+}
+
+function removePendingSanitization(id) {
+  let pendingSanitizations = safeGetPendingSanitizations();
+  let i = pendingSanitizations.findIndex(s => s.id == id);
+  let [s] = pendingSanitizations.splice(i, 1);
+  Services.prefs.setStringPref(
+    Sanitizer.PREF_PENDING_SANITIZATIONS,
+    JSON.stringify(pendingSanitizations)
+  );
+  return s;
+}
+
+function getAndClearPendingSanitizations() {
+  let pendingSanitizations = safeGetPendingSanitizations();
+  if (pendingSanitizations.length) {
+    Services.prefs.clearUserPref(Sanitizer.PREF_PENDING_SANITIZATIONS);
+  }
+  return pendingSanitizations;
+}
+
+function safeGetPendingSanitizations() {
+  try {
+    return JSON.parse(
+      Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+    );
+  } catch (ex) {
+    console.error("Invalid JSON value for pending sanitizations: ", ex);
+    return [];
+  }
+}
+
+async function clearData(range, flags) {
+  if (range) {
+    await new Promise(resolve => {
+      Services.clearData.deleteDataInTimeRange(
+        range[0],
+        range[1],
+        true /* user request */,
+        flags,
+        resolve
+      );
+    });
+  } else {
+    await new Promise(resolve => {
+      Services.clearData.deleteData(flags, resolve);
+    });
+  }
+}
+
+function isSupportedPrincipal(principal) {
+  return ["http", "https", "file"].some(scheme => principal.schemeIs(scheme));
+}
diff --git a/browser/modules/SelectionChangedMenulist.sys.mjs b/browser/modules/SelectionChangedMenulist.sys.mjs
new file mode 100644
index 0000000000..fd794004ed
--- /dev/null
+++ b/browser/modules/SelectionChangedMenulist.sys.mjs
@@ -0,0 +1,28 @@
+/* - 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/. */
+
+export class SelectionChangedMenulist {
+  // A menulist wrapper that will open the popup when navigating with the
+  // keyboard on Windows and trigger the provided handler when the popup
+  // is hiding. This matches the behaviour of MacOS and Linux more closely.
+
+  constructor(menulist, onCommand) {
+    let popup = menulist.menupopup;
+    let lastEvent;
+
+    menulist.addEventListener("command", event => {
+      lastEvent = event;
+      if (popup.state != "open" && popup.state != "showing") {
+        popup.openPopup();
+      }
+    });
+
+    popup.addEventListener("popuphiding", () => {
+      if (lastEvent) {
+        onCommand(lastEvent);
+        lastEvent = null;
+      }
+    });
+  }
+}
diff --git a/browser/modules/SiteDataManager.sys.mjs b/browser/modules/SiteDataManager.sys.mjs
new file mode 100644
index 0000000000..c5569afc82
--- /dev/null
+++ b/browser/modules/SiteDataManager.sys.mjs
@@ -0,0 +1,705 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineLazyGetter(lazy, "gStringBundle", function () {
+  return Services.strings.createBundle(
+    "chrome://browser/locale/siteData.properties"
+  );
+});
+
+ChromeUtils.defineLazyGetter(lazy, "gBrandBundle", function () {
+  return Services.strings.createBundle(
+    "chrome://branding/locale/brand.properties"
+  );
+});
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Sanitizer: "resource:///modules/Sanitizer.sys.mjs",
+});
+
+export var SiteDataManager = {
+  // A Map of sites and their disk usage according to Quota Manager.
+  // Key is base domain (group sites based on base domain across scheme, port,
+  // origin attributes) or host if the entry does not have a base domain.
+  // Value is one object holding:
+  //   - baseDomainOrHost: Same as key.
+  //   - principals: instances of nsIPrincipal (only when the site has
+  //     quota storage).
+  //   - persisted: the persistent-storage status.
+  //   - quotaUsage: the usage of indexedDB and localStorage.
+  //   - containersData: a map containing cookiesBlocked,lastAccessed and quotaUsage by userContextID.
+  _sites: new Map(),
+
+  _getCacheSizeObserver: null,
+
+  _getCacheSizePromise: null,
+
+  _getQuotaUsagePromise: null,
+
+  _quotaUsageRequest: null,
+
+  /**
+   *  Retrieve the latest site data and store it in SiteDataManager.
+   *
+   *  Updating site data is a *very* expensive operation. This method exists so that
+   *  consumers can manually decide when to update, most methods on SiteDataManager
+   *  will not trigger updates automatically.
+   *
+   *  It is *highly discouraged* to await on this function to finish before showing UI.
+   *  Either trigger the update some time before the data is needed or use the
+   *  entryUpdatedCallback parameter to update the UI async.
+   *
+   * @param {entryUpdatedCallback} a function to be called whenever a site is added or
+   *        updated. This can be used to e.g. fill a UI that lists sites without
+   *        blocking on the entire update to finish.
+   * @returns a Promise that resolves when updating is done.
+   **/
+  async updateSites(entryUpdatedCallback) {
+    Services.obs.notifyObservers(null, "sitedatamanager:updating-sites");
+    // Clear old data and requests first
+    this._sites.clear();
+    this._getAllCookies(entryUpdatedCallback);
+    await this._getQuotaUsage(entryUpdatedCallback);
+    Services.obs.notifyObservers(null, "sitedatamanager:sites-updated");
+  },
+
+  /**
+   * Get the base domain of a host on a best-effort basis.
+   * @param {string} host - Host to convert.
+   * @returns {string} Computed base domain. If the base domain cannot be
+   * determined, because the host is an IP address or does not have enough
+   * domain levels we will return the original host. This includes the empty
+   * string.
+   * @throws {Error} Throws for unexpected conversion errors from eTLD service.
+   */
+  getBaseDomainFromHost(host) {
+    let result = host;
+    try {
+      result = Services.eTLD.getBaseDomainFromHost(host);
+    } catch (e) {
+      if (
+        e.result == Cr.NS_ERROR_HOST_IS_IP_ADDRESS ||
+        e.result == Cr.NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS
+      ) {
+        // For these 2 expected errors, just take the host as the result.
+        // - NS_ERROR_HOST_IS_IP_ADDRESS: the host is in ipv4/ipv6.
+        // - NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS: not enough domain parts to extract.
+        result = host;
+      } else {
+        throw e;
+      }
+    }
+    return result;
+  },
+
+  _getOrInsertSite(baseDomainOrHost) {
+    let site = this._sites.get(baseDomainOrHost);
+    if (!site) {
+      site = {
+        baseDomainOrHost,
+        cookies: [],
+        persisted: false,
+        quotaUsage: 0,
+        lastAccessed: 0,
+        principals: [],
+      };
+      this._sites.set(baseDomainOrHost, site);
+    }
+    return site;
+  },
+
+  /**
+   * Insert site with specific params into the SiteDataManager
+   * Currently used for testing purposes
+   *
+   * @param {String} baseDomainOrHost
+   * @param {Object} Site info params
+   * @returns {Object} site object
+   */
+  _testInsertSite(
+    baseDomainOrHost,
+    {
+      cookies = [],
+      persisted = false,
+      quotaUsage = 0,
+      lastAccessed = 0,
+      principals = [],
+    }
+  ) {
+    let site = {
+      baseDomainOrHost,
+      cookies,
+      persisted,
+      quotaUsage,
+      lastAccessed,
+      principals,
+    };
+    this._sites.set(baseDomainOrHost, site);
+
+    return site;
+  },
+
+  _getOrInsertContainersData(site, userContextId) {
+    if (!site.containersData) {
+      site.containersData = new Map();
+    }
+
+    let containerData = site.containersData.get(userContextId);
+    if (!containerData) {
+      containerData = {
+        cookiesBlocked: 0,
+        lastAccessed: new Date(0),
+        quotaUsage: 0,
+      };
+      site.containersData.set(userContextId, containerData);
+    }
+    return containerData;
+  },
+
+  /**
+   * Retrieves the amount of space currently used by disk cache.
+   *
+   * You can use DownloadUtils.convertByteUnits to convert this to
+   * a user-understandable size/unit combination.
+   *
+   * @returns a Promise that resolves with the cache size on disk in bytes.
+   */
+  getCacheSize() {
+    if (this._getCacheSizePromise) {
+      return this._getCacheSizePromise;
+    }
+
+    this._getCacheSizePromise = new Promise((resolve, reject) => {
+      // Needs to root the observer since cache service keeps only a weak reference.
+      this._getCacheSizeObserver = {
+        onNetworkCacheDiskConsumption: consumption => {
+          resolve(consumption);
+          this._getCacheSizePromise = null;
+          this._getCacheSizeObserver = null;
+        },
+
+        QueryInterface: ChromeUtils.generateQI([
+          "nsICacheStorageConsumptionObserver",
+          "nsISupportsWeakReference",
+        ]),
+      };
+
+      try {
+        Services.cache2.asyncGetDiskConsumption(this._getCacheSizeObserver);
+      } catch (e) {
+        reject(e);
+        this._getCacheSizePromise = null;
+        this._getCacheSizeObserver = null;
+      }
+    });
+
+    return this._getCacheSizePromise;
+  },
+
+  _getQuotaUsage(entryUpdatedCallback) {
+    this._cancelGetQuotaUsage();
+    this._getQuotaUsagePromise = new Promise(resolve => {
+      let onUsageResult = request => {
+        if (request.resultCode == Cr.NS_OK) {
+          let items = request.result;
+          for (let item of items) {
+            if (!item.persisted && item.usage <= 0) {
+              // An non-persistent-storage site with 0 byte quota usage is redundant for us so skip it.
+              continue;
+            }
+            let principal =
+              Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+                item.origin
+              );
+            if (principal.schemeIs("http") || principal.schemeIs("https")) {
+              // Group dom storage by first party. If an entry is partitioned
+              // the first party site will be in the partitionKey, instead of
+              // the principal baseDomain.
+              let pkBaseDomain;
+              try {
+                pkBaseDomain = ChromeUtils.getBaseDomainFromPartitionKey(
+                  principal.originAttributes.partitionKey
+                );
+              } catch (e) {
+                console.error(e);
+              }
+              let site = this._getOrInsertSite(
+                pkBaseDomain || principal.baseDomain
+              );
+              // Assume 3 sites:
+              //   - Site A (not persisted): https://www.foo.com
+              //   - Site B (not persisted): https://www.foo.com^userContextId=2
+              //   - Site C (persisted):     https://www.foo.com:1234
+              //     Although only C is persisted, grouping by base domain, as a
+              //     result, we still mark as persisted here under this base
+              //     domain group.
+              if (item.persisted) {
+                site.persisted = true;
+              }
+              if (site.lastAccessed < item.lastAccessed) {
+                site.lastAccessed = item.lastAccessed;
+              }
+              if (Number.isInteger(principal.userContextId)) {
+                let containerData = this._getOrInsertContainersData(
+                  site,
+                  principal.userContextId
+                );
+                containerData.quotaUsage = item.usage;
+                let itemTime = item.lastAccessed / 1000;
+                if (containerData.lastAccessed.getTime() < itemTime) {
+                  containerData.lastAccessed.setTime(itemTime);
+                }
+              }
+              site.principals.push(principal);
+              site.quotaUsage += item.usage;
+              if (entryUpdatedCallback) {
+                entryUpdatedCallback(principal.baseDomain, site);
+              }
+            }
+          }
+        }
+        resolve();
+      };
+      // XXX: The work of integrating localStorage into Quota Manager is in progress.
+      //      After the bug 742822 and 1286798 landed, localStorage usage will be included.
+      //      So currently only get indexedDB usage.
+      this._quotaUsageRequest = Services.qms.getUsage(onUsageResult);
+    });
+    return this._getQuotaUsagePromise;
+  },
+
+  _getAllCookies(entryUpdatedCallback) {
+    for (let cookie of Services.cookies.cookies) {
+      // Group cookies by first party. If a cookie is partitioned the
+      // partitionKey will contain the first party site, instead of the host
+      // field.
+      let pkBaseDomain;
+      try {
+        pkBaseDomain = ChromeUtils.getBaseDomainFromPartitionKey(
+          cookie.originAttributes.partitionKey
+        );
+      } catch (e) {
+        console.error(e);
+      }
+      let baseDomainOrHost =
+        pkBaseDomain || this.getBaseDomainFromHost(cookie.rawHost);
+      let site = this._getOrInsertSite(baseDomainOrHost);
+      if (entryUpdatedCallback) {
+        entryUpdatedCallback(baseDomainOrHost, site);
+      }
+      site.cookies.push(cookie);
+      if (Number.isInteger(cookie.originAttributes.userContextId)) {
+        let containerData = this._getOrInsertContainersData(
+          site,
+          cookie.originAttributes.userContextId
+        );
+        containerData.cookiesBlocked += 1;
+        let cookieTime = cookie.lastAccessed / 1000;
+        if (containerData.lastAccessed.getTime() < cookieTime) {
+          containerData.lastAccessed.setTime(cookieTime);
+        }
+      }
+      if (site.lastAccessed < cookie.lastAccessed) {
+        site.lastAccessed = cookie.lastAccessed;
+      }
+    }
+  },
+
+  _cancelGetQuotaUsage() {
+    if (this._quotaUsageRequest) {
+      this._quotaUsageRequest.cancel();
+      this._quotaUsageRequest = null;
+    }
+  },
+
+  /**
+   * Checks if the site with the provided ASCII host is using any site data at all.
+   * This will check for:
+   *   - Cookies (incl. subdomains)
+   *   - Quota Usage
+   * in that order. This function is meant to be fast, and thus will
+   * end searching and return true once the first trace of site data is found.
+   *
+   * @param {String} the ASCII host to check
+   * @returns {Boolean} whether the site has any data associated with it
+   */
+  async hasSiteData(asciiHost) {
+    if (Services.cookies.countCookiesFromHost(asciiHost)) {
+      return true;
+    }
+
+    let hasQuota = await new Promise(resolve => {
+      Services.qms.getUsage(request => {
+        if (request.resultCode != Cr.NS_OK) {
+          resolve(false);
+          return;
+        }
+
+        for (let item of request.result) {
+          if (!item.persisted && item.usage <= 0) {
+            continue;
+          }
+
+          let principal =
+            Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+              item.origin
+            );
+          if (principal.asciiHost == asciiHost) {
+            resolve(true);
+            return;
+          }
+        }
+
+        resolve(false);
+      });
+    });
+
+    if (hasQuota) {
+      return true;
+    }
+
+    return false;
+  },
+
+  /**
+   * Fetches total quota usage
+   * This method assumes that siteDataManager.updateSites has been called externally
+   *
+   * @returns total quota usage
+   */
+  getTotalUsage() {
+    return this._getQuotaUsagePromise.then(() => {
+      let usage = 0;
+      for (let site of this._sites.values()) {
+        usage += site.quotaUsage;
+      }
+      return usage;
+    });
+  },
+
+  /**
+   *
+   * Fetch quota usage for all time ranges to display in the clear data dialog.
+   * This method assumes that SiteDataManager.updateSites has been called externally
+   *
+   * @param {string[]} timeSpanArr - Array of timespan options to get quota usage
+   *              from Sanitizer, e.g. ["TIMESPAN_HOUR", "TIMESPAN_2HOURS"]
+   * @returns {Object} bytes used for each timespan
+   */
+  async getQuotaUsageForTimeRanges(timeSpanArr) {
+    let usage = {};
+    await this._getQuotaUsagePromise;
+
+    for (let timespan of timeSpanArr) {
+      usage[timespan] = 0;
+    }
+
+    let timeNow = Date.now();
+    for (let site of this._sites.values()) {
+      let lastAccessed = new Date(site.lastAccessed / 1000);
+      for (let timeSpan of timeSpanArr) {
+        let compareTime = new Date(
+          timeNow - lazy.Sanitizer.timeSpanMsMap[timeSpan]
+        );
+
+        if (timeSpan === "TIMESPAN_EVERYTHING") {
+          usage[timeSpan] += site.quotaUsage;
+        } else if (lastAccessed >= compareTime) {
+          usage[timeSpan] += site.quotaUsage;
+        }
+      }
+    }
+    return usage;
+  },
+
+  /**
+   * Gets all sites that are currently storing site data. Entries are grouped by
+   * parent base domain if applicable. For example "foo.example.com",
+   * "example.com" and "bar.example.com" will have one entry with the baseDomain
+   * "example.com".
+   * A base domain entry will represent all data of its storage jar. The storage
+   * jar holds all first party data of the domain as well as any third party
+   * data partitioned under the domain. Additionally we will add data which
+   * belongs to the domain but is part of other domains storage jars . That is
+   * data third-party partitioned under other domains.
+   * Sites which cannot be associated with a base domain, for example IP hosts,
+   * are not grouped.
+   *
+   * The list is not automatically up-to-date. You need to call
+   * {@link updateSites} before you can use this method for the first time (and
+   * whenever you want to get an updated set of list.)
+   *
+   * @returns {Promise} Promise that resolves with the list of all sites.
+   */
+  async getSites() {
+    await this._getQuotaUsagePromise;
+
+    return Array.from(this._sites.values()).map(site => ({
+      baseDomain: site.baseDomainOrHost,
+      cookies: site.cookies,
+      usage: site.quotaUsage,
+      containersData: site.containersData,
+      persisted: site.persisted,
+      lastAccessed: new Date(site.lastAccessed / 1000),
+    }));
+  },
+
+  /**
+   * Get site, which stores data, by base domain or host.
+   *
+   * The list is not automatically up-to-date. You need to call
+   * {@link updateSites} before you can use this method for the first time (and
+   * whenever you want to get an updated set of list.)
+   *
+   * @param {String} baseDomainOrHost - Base domain or host of the site to get.
+   *
+   * @returns {Promise<Object|null>} Promise that resolves with the site object
+   * or null if no site with given base domain or host stores data.
+   */
+  async getSite(baseDomainOrHost) {
+    let baseDomain = this.getBaseDomainFromHost(baseDomainOrHost);
+
+    let site = this._sites.get(baseDomain);
+    if (!site) {
+      return null;
+    }
+    return {
+      baseDomain: site.baseDomainOrHost,
+      cookies: site.cookies,
+      usage: site.quotaUsage,
+      containersData: site.containersData,
+      persisted: site.persisted,
+      lastAccessed: new Date(site.lastAccessed / 1000),
+    };
+  },
+
+  _removePermission(site) {
+    let removals = new Set();
+    for (let principal of site.principals) {
+      let { originNoSuffix } = principal;
+      if (removals.has(originNoSuffix)) {
+        // In case of encountering
+        //   - https://www.foo.com
+        //   - https://www.foo.com^userContextId=2
+        // because setting/removing permission is across OAs already so skip the same origin without suffix
+        continue;
+      }
+      removals.add(originNoSuffix);
+      Services.perms.removeFromPrincipal(principal, "persistent-storage");
+    }
+  },
+
+  _removeCookies(site) {
+    for (let cookie of site.cookies) {
+      Services.cookies.remove(
+        cookie.host,
+        cookie.name,
+        cookie.path,
+        cookie.originAttributes
+      );
+    }
+    site.cookies = [];
+  },
+
+  // Returns a list of permissions from the permission manager that
+  // we consider part of "site data and cookies".
+  _getDeletablePermissions() {
+    let perms = [];
+
+    for (let permission of Services.perms.all) {
+      if (
+        permission.type == "persistent-storage" ||
+        permission.type == "storage-access"
+      ) {
+        perms.push(permission);
+      }
+    }
+
+    return perms;
+  },
+
+  /**
+   * Removes all site data for the specified list of domains and hosts.
+   * This includes site data of subdomains belonging to the domains or hosts and
+   * partitioned storage. Data is cleared per storage jar, which means if we
+   * clear "example.com", we will also clear third parties embedded on
+   * "example.com". Additionally we will clear all data of "example.com" (as a
+   * third party) from other jars.
+   *
+   * @param {string|string[]} domainsOrHosts - List of domains and hosts or
+   * single domain or host to remove.
+   * @returns {Promise} Promise that resolves when data is removed and the site
+   * data manager has been updated.
+   */
+  async remove(domainsOrHosts) {
+    if (domainsOrHosts == null) {
+      throw new Error("domainsOrHosts is required.");
+    }
+    // Allow the caller to pass a single base domain or host.
+    if (!Array.isArray(domainsOrHosts)) {
+      domainsOrHosts = [domainsOrHosts];
+    }
+    let perms = this._getDeletablePermissions();
+    let promises = [];
+    for (let domainOrHost of domainsOrHosts) {
+      const kFlags =
+        Ci.nsIClearDataService.CLEAR_COOKIES |
+        Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+        Ci.nsIClearDataService.CLEAR_EME |
+        Ci.nsIClearDataService.CLEAR_ALL_CACHES |
+        Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD |
+        Ci.nsIClearDataService.CLEAR_FINGERPRINTING_PROTECTION_STATE |
+        Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE;
+      promises.push(
+        new Promise(function (resolve) {
+          const { clearData } = Services;
+          if (domainOrHost) {
+            // First try to clear by base domain for aDomainOrHost. If we can't
+            // get a base domain, fall back to clearing by just host.
+            try {
+              clearData.deleteDataFromBaseDomain(
+                domainOrHost,
+                true,
+                kFlags,
+                resolve
+              );
+            } catch (e) {
+              if (
+                e.result != Cr.NS_ERROR_HOST_IS_IP_ADDRESS &&
+                e.result != Cr.NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS
+              ) {
+                throw e;
+              }
+              clearData.deleteDataFromHost(domainOrHost, true, kFlags, resolve);
+            }
+          } else {
+            clearData.deleteDataFromLocalFiles(true, kFlags, resolve);
+          }
+        })
+      );
+
+      for (let perm of perms) {
+        // Specialcase local file permissions.
+        if (!domainOrHost) {
+          if (perm.principal.schemeIs("file")) {
+            Services.perms.removePermission(perm);
+          }
+        } else if (
+          Services.eTLD.hasRootDomain(perm.principal.host, domainOrHost)
+        ) {
+          Services.perms.removePermission(perm);
+        }
+      }
+    }
+
+    await Promise.all(promises);
+
+    return this.updateSites();
+  },
+
+  /**
+   * In the specified window, shows a prompt for removing all site data or the
+   * specified list of base domains or hosts, warning the user that this may log
+   * them out of websites.
+   *
+   * @param {mozIDOMWindowProxy} win - a parent DOM window to host the dialog.
+   * @param {string[]} [removals] - an array of base domain or host strings that
+   * will be removed.
+   * @returns {boolean} whether the user confirmed the prompt.
+   */
+  promptSiteDataRemoval(win, removals) {
+    if (removals) {
+      let args = {
+        hosts: removals,
+        allowed: false,
+      };
+      let features = "centerscreen,chrome,modal,resizable=no";
+      win.browsingContext.topChromeWindow.openDialog(
+        "chrome://browser/content/preferences/dialogs/siteDataRemoveSelected.xhtml",
+        "",
+        features,
+        args
+      );
+      return args.allowed;
+    }
+
+    let brandName = lazy.gBrandBundle.GetStringFromName("brandShortName");
+    let flags =
+      Services.prompt.BUTTON_TITLE_IS_STRING * Services.prompt.BUTTON_POS_0 +
+      Services.prompt.BUTTON_TITLE_CANCEL * Services.prompt.BUTTON_POS_1 +
+      Services.prompt.BUTTON_POS_0_DEFAULT;
+    let title = lazy.gStringBundle.GetStringFromName(
+      "clearSiteDataPromptTitle"
+    );
+    let text = lazy.gStringBundle.formatStringFromName(
+      "clearSiteDataPromptText",
+      [brandName]
+    );
+    let btn0Label = lazy.gStringBundle.GetStringFromName("clearSiteDataNow");
+
+    let result = Services.prompt.confirmEx(
+      win,
+      title,
+      text,
+      flags,
+      btn0Label,
+      null,
+      null,
+      null,
+      {}
+    );
+    return result == 0;
+  },
+
+  /**
+   * Clears all site data and cache
+   *
+   * @returns a Promise that resolves when the data is cleared.
+   */
+  async removeAll() {
+    await this.removeCache();
+    return this.removeSiteData();
+  },
+
+  /**
+   * Clears all caches.
+   *
+   * @returns a Promise that resolves when the data is cleared.
+   */
+  removeCache() {
+    return new Promise(function (resolve) {
+      Services.clearData.deleteData(
+        Ci.nsIClearDataService.CLEAR_ALL_CACHES,
+        resolve
+      );
+    });
+  },
+
+  /**
+   * Clears all site data, but not cache, because the UI offers
+   * that functionality separately.
+   *
+   * @returns a Promise that resolves when the data is cleared.
+   */
+  async removeSiteData() {
+    await new Promise(function (resolve) {
+      Services.clearData.deleteData(
+        Ci.nsIClearDataService.CLEAR_COOKIES |
+          Ci.nsIClearDataService.CLEAR_DOM_STORAGES |
+          Ci.nsIClearDataService.CLEAR_HSTS |
+          Ci.nsIClearDataService.CLEAR_EME |
+          Ci.nsIClearDataService.CLEAR_BOUNCE_TRACKING_PROTECTION_STATE,
+        resolve
+      );
+    });
+
+    for (let permission of this._getDeletablePermissions()) {
+      Services.perms.removePermission(permission);
+    }
+
+    return this.updateSites();
+  },
+};
diff --git a/browser/modules/SitePermissions.sys.mjs b/browser/modules/SitePermissions.sys.mjs
new file mode 100644
index 0000000000..2f3f9210e2
--- /dev/null
+++ b/browser/modules/SitePermissions.sys.mjs
@@ -0,0 +1,1327 @@
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+var gStringBundle = Services.strings.createBundle(
+  "chrome://browser/locale/sitePermissions.properties"
+);
+
+/**
+ * A helper module to manage temporary permissions.
+ *
+ * Permissions are keyed by browser, so methods take a Browser
+ * element to identify the corresponding permission set.
+ *
+ * This uses a WeakMap to key browsers, so that entries are
+ * automatically cleared once the browser stops existing
+ * (once there are no other references to the browser object);
+ */
+const TemporaryPermissions = {
+  // This is a three level deep map with the following structure:
+  //
+  // Browser => {
+  //   <baseDomain|origin>: {
+  //     <permissionID>: {state: Number, expireTimeout: Number}
+  //   }
+  // }
+  //
+  // Only the top level browser elements are stored via WeakMap. The WeakMap
+  // value is an object with URI baseDomains or origins as keys. The keys of
+  // that object are ids that identify permissions that were set for the
+  // specific URI. The final value is an object containing the permission state
+  // and the id of the timeout which will cause permission expiry.
+  // BLOCK permissions are keyed under baseDomain to prevent bypassing the block
+  // (see Bug 1492668). Any other permissions are keyed under origin.
+  _stateByBrowser: new WeakMap(),
+
+  // Extract baseDomain from uri. Fallback to hostname on conversion error.
+  _uriToBaseDomain(uri) {
+    try {
+      return Services.eTLD.getBaseDomain(uri);
+    } catch (error) {
+      if (
+        error.result !== Cr.NS_ERROR_HOST_IS_IP_ADDRESS &&
+        error.result !== Cr.NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS
+      ) {
+        throw error;
+      }
+      return uri.host;
+    }
+  },
+
+  /**
+   * Generate keys to store temporary permissions under. The strict key is
+   * origin, non-strict is baseDomain.
+   * @param {nsIPrincipal} principal - principal to derive keys from.
+   * @returns {Object} keys - Object containing the generated permission keys.
+   * @returns {string} keys.strict - Key to be used for strict matching.
+   * @returns {string} keys.nonStrict - Key to be used for non-strict matching.
+   * @throws {Error} - Throws if principal is undefined or no valid permission key can
+   * be generated.
+   */
+  _getKeysFromPrincipal(principal) {
+    return { strict: principal.origin, nonStrict: principal.baseDomain };
+  },
+
+  /**
+   * Sets a new permission for the specified browser.
+   * @returns {boolean} whether the permission changed, effectively.
+   */
+  set(
+    browser,
+    id,
+    state,
+    expireTimeMS,
+    principal = browser.contentPrincipal,
+    expireCallback
+  ) {
+    if (
+      !browser ||
+      !principal ||
+      !SitePermissions.isSupportedPrincipal(principal)
+    ) {
+      return false;
+    }
+    let entry = this._stateByBrowser.get(browser);
+    if (!entry) {
+      entry = { browser: Cu.getWeakReference(browser), uriToPerm: {} };
+      this._stateByBrowser.set(browser, entry);
+    }
+    let { uriToPerm } = entry;
+    // We store blocked permissions by baseDomain. Other states by origin.
+    let { strict, nonStrict } = this._getKeysFromPrincipal(principal);
+    let setKey;
+    let deleteKey;
+    // Differentiate between block and non-block permissions. If we store a
+    // block permission we need to delete old entries which may be set under
+    // origin before setting the new permission for baseDomain. For non-block
+    // permissions this is swapped.
+    if (state == SitePermissions.BLOCK) {
+      setKey = nonStrict;
+      deleteKey = strict;
+    } else {
+      setKey = strict;
+      deleteKey = nonStrict;
+    }
+
+    if (!uriToPerm[setKey]) {
+      uriToPerm[setKey] = {};
+    }
+
+    let expireTimeout = uriToPerm[setKey][id]?.expireTimeout;
+    let previousState = uriToPerm[setKey][id]?.state;
+    // If overwriting a permission state. We need to cancel the old timeout.
+    if (expireTimeout) {
+      lazy.clearTimeout(expireTimeout);
+    }
+    // Construct the new timeout to remove the permission once it has expired.
+    expireTimeout = lazy.setTimeout(() => {
+      let entryBrowser = entry.browser.get();
+      // Exit early if the browser is no longer alive when we get the timeout
+      // callback.
+      if (!entryBrowser || !uriToPerm[setKey]) {
+        return;
+      }
+      delete uriToPerm[setKey][id];
+      // Notify SitePermissions that a temporary permission has expired.
+      // Get the browser the permission is currently set for. If this.copy was
+      // used this browser is different from the original one passed above.
+      expireCallback(entryBrowser);
+    }, expireTimeMS);
+    uriToPerm[setKey][id] = {
+      expireTimeout,
+      state,
+    };
+
+    // If we set a permission state for a origin we need to reset the old state
+    // which may be set for baseDomain and vice versa. An individual permission
+    // must only ever be keyed by either origin or baseDomain.
+    let permissions = uriToPerm[deleteKey];
+    if (permissions) {
+      expireTimeout = permissions[id]?.expireTimeout;
+      if (expireTimeout) {
+        lazy.clearTimeout(expireTimeout);
+      }
+      delete permissions[id];
+    }
+
+    return state != previousState;
+  },
+
+  /**
+   * Removes a permission with the specified id for the specified browser.
+   * @returns {boolean} whether the permission was removed.
+   */
+  remove(browser, id) {
+    if (
+      !browser ||
+      !SitePermissions.isSupportedPrincipal(browser.contentPrincipal) ||
+      !this._stateByBrowser.has(browser)
+    ) {
+      return false;
+    }
+    // Permission can be stored by any of the two keys (strict and non-strict).
+    // getKeysFromURI can throw. We let the caller handle the exception.
+    let { strict, nonStrict } = this._getKeysFromPrincipal(
+      browser.contentPrincipal
+    );
+    let { uriToPerm } = this._stateByBrowser.get(browser);
+    for (let key of [nonStrict, strict]) {
+      if (uriToPerm[key]?.[id] != null) {
+        let { expireTimeout } = uriToPerm[key][id];
+        if (expireTimeout) {
+          lazy.clearTimeout(expireTimeout);
+        }
+        delete uriToPerm[key][id];
+        // Individual permissions can only ever be keyed either strict or
+        // non-strict. If we find the permission via the first key run we can
+        // return early.
+        return true;
+      }
+    }
+    return false;
+  },
+
+  // Gets a permission with the specified id for the specified browser.
+  get(browser, id) {
+    if (
+      !browser ||
+      !browser.contentPrincipal ||
+      !SitePermissions.isSupportedPrincipal(browser.contentPrincipal) ||
+      !this._stateByBrowser.has(browser)
+    ) {
+      return null;
+    }
+    let { uriToPerm } = this._stateByBrowser.get(browser);
+
+    let { strict, nonStrict } = this._getKeysFromPrincipal(
+      browser.contentPrincipal
+    );
+    for (let key of [nonStrict, strict]) {
+      if (uriToPerm[key]) {
+        let permission = uriToPerm[key][id];
+        if (permission) {
+          return {
+            id,
+            state: permission.state,
+            scope: SitePermissions.SCOPE_TEMPORARY,
+          };
+        }
+      }
+    }
+    return null;
+  },
+
+  // Gets all permissions for the specified browser.
+  // Note that only permissions that apply to the current URI
+  // of the passed browser element will be returned.
+  getAll(browser) {
+    let permissions = [];
+    if (
+      !SitePermissions.isSupportedPrincipal(browser.contentPrincipal) ||
+      !this._stateByBrowser.has(browser)
+    ) {
+      return permissions;
+    }
+    let { uriToPerm } = this._stateByBrowser.get(browser);
+
+    let { strict, nonStrict } = this._getKeysFromPrincipal(
+      browser.contentPrincipal
+    );
+    for (let key of [nonStrict, strict]) {
+      if (uriToPerm[key]) {
+        let perms = uriToPerm[key];
+        for (let id of Object.keys(perms)) {
+          let permission = perms[id];
+          if (permission) {
+            permissions.push({
+              id,
+              state: permission.state,
+              scope: SitePermissions.SCOPE_TEMPORARY,
+            });
+          }
+        }
+      }
+    }
+
+    return permissions;
+  },
+
+  // Clears all permissions for the specified browser.
+  // Unlike other methods, this does NOT clear only for
+  // the currentURI but the whole browser state.
+
+  /**
+   * Clear temporary permissions for the specified browser. Unlike other
+   * methods, this does NOT clear only for the currentURI but the whole browser
+   * state.
+   * @param {Browser} browser - Browser to clear permissions for.
+   * @param {Number} [filterState] - Only clear permissions with the given state
+   * value. Defaults to all permissions.
+   */
+  clear(browser, filterState = null) {
+    let entry = this._stateByBrowser.get(browser);
+    if (!entry?.uriToPerm) {
+      return;
+    }
+
+    let { uriToPerm } = entry;
+    Object.entries(uriToPerm).forEach(([uriKey, permissions]) => {
+      Object.entries(permissions).forEach(
+        ([permId, { state, expireTimeout }]) => {
+          // We need to explicitly check for null or undefined here, because the
+          // permission state may be 0.
+          if (filterState != null) {
+            if (state != filterState) {
+              // Skip permission entry if it doesn't match the filter.
+              return;
+            }
+            delete permissions[permId];
+          }
+          // For the clear-all case we remove the entire browser entry, so we
+          // only need to clear the timeouts.
+          if (!expireTimeout) {
+            return;
+          }
+          lazy.clearTimeout(expireTimeout);
+        }
+      );
+      // If there are no more permissions, remove the entry from the URI map.
+      if (filterState != null && !Object.keys(permissions).length) {
+        delete uriToPerm[uriKey];
+      }
+    });
+
+    // We're either clearing all permissions or only the permissions with state
+    // == filterState. If we have a filter, we can only clean up the browser if
+    // there are no permission entries left in the map.
+    if (filterState == null || !Object.keys(uriToPerm).length) {
+      this._stateByBrowser.delete(browser);
+    }
+  },
+
+  // Copies the temporary permission state of one browser
+  // into a new entry for the other browser.
+  copy(browser, newBrowser) {
+    let entry = this._stateByBrowser.get(browser);
+    if (entry) {
+      entry.browser = Cu.getWeakReference(newBrowser);
+      this._stateByBrowser.set(newBrowser, entry);
+    }
+  },
+};
+
+// This hold a flag per browser to indicate whether we should show the
+// user a notification as a permission has been requested that has been
+// blocked globally. We only want to notify the user in the case that
+// they actually requested the permission within the current page load
+// so will clear the flag on navigation.
+const GloballyBlockedPermissions = {
+  _stateByBrowser: new WeakMap(),
+
+  /**
+   * @returns {boolean} whether the permission was removed.
+   */
+  set(browser, id) {
+    if (!this._stateByBrowser.has(browser)) {
+      this._stateByBrowser.set(browser, {});
+    }
+    let entry = this._stateByBrowser.get(browser);
+    let origin = browser.contentPrincipal.origin;
+    if (!entry[origin]) {
+      entry[origin] = {};
+    }
+
+    if (entry[origin][id]) {
+      return false;
+    }
+    entry[origin][id] = true;
+
+    // Clear the flag and remove the listener once the user has navigated.
+    // WebProgress will report various things including hashchanges to us, the
+    // navigation we care about is either leaving the current page or reloading.
+    let { prePath } = browser.currentURI;
+    browser.addProgressListener(
+      {
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIWebProgressListener",
+          "nsISupportsWeakReference",
+        ]),
+        onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
+          let hasLeftPage =
+            aLocation.prePath != prePath ||
+            !(aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT);
+          let isReload = !!(
+            aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_RELOAD
+          );
+
+          if (aWebProgress.isTopLevel && (hasLeftPage || isReload)) {
+            GloballyBlockedPermissions.remove(browser, id, origin);
+            browser.removeProgressListener(this);
+          }
+        },
+      },
+      Ci.nsIWebProgress.NOTIFY_LOCATION
+    );
+    return true;
+  },
+
+  // Removes a permission with the specified id for the specified browser.
+  remove(browser, id, origin = null) {
+    let entry = this._stateByBrowser.get(browser);
+    if (!origin) {
+      origin = browser.contentPrincipal.origin;
+    }
+    if (entry && entry[origin]) {
+      delete entry[origin][id];
+    }
+  },
+
+  // Gets all permissions for the specified browser.
+  // Note that only permissions that apply to the current URI
+  // of the passed browser element will be returned.
+  getAll(browser) {
+    let permissions = [];
+    let entry = this._stateByBrowser.get(browser);
+    let origin = browser.contentPrincipal.origin;
+    if (entry && entry[origin]) {
+      let timeStamps = entry[origin];
+      for (let id of Object.keys(timeStamps)) {
+        permissions.push({
+          id,
+          state: gPermissions.get(id).getDefault(),
+          scope: SitePermissions.SCOPE_GLOBAL,
+        });
+      }
+    }
+    return permissions;
+  },
+
+  // Copies the globally blocked permission state of one browser
+  // into a new entry for the other browser.
+  copy(browser, newBrowser) {
+    let entry = this._stateByBrowser.get(browser);
+    if (entry) {
+      this._stateByBrowser.set(newBrowser, entry);
+    }
+  },
+};
+
+/**
+ * A module to manage permanent and temporary permissions
+ * by URI and browser.
+ *
+ * Some methods have the side effect of dispatching a "PermissionStateChange"
+ * event on changes to temporary permissions, as mentioned in the respective docs.
+ */
+export var SitePermissions = {
+  // Permission states.
+  UNKNOWN: Services.perms.UNKNOWN_ACTION,
+  ALLOW: Services.perms.ALLOW_ACTION,
+  BLOCK: Services.perms.DENY_ACTION,
+  PROMPT: Services.perms.PROMPT_ACTION,
+  ALLOW_COOKIES_FOR_SESSION: Ci.nsICookiePermission.ACCESS_SESSION,
+  AUTOPLAY_BLOCKED_ALL: Ci.nsIAutoplay.BLOCKED_ALL,
+
+  // Permission scopes.
+  SCOPE_REQUEST: "{SitePermissions.SCOPE_REQUEST}",
+  SCOPE_TEMPORARY: "{SitePermissions.SCOPE_TEMPORARY}",
+  SCOPE_SESSION: "{SitePermissions.SCOPE_SESSION}",
+  SCOPE_PERSISTENT: "{SitePermissions.SCOPE_PERSISTENT}",
+  SCOPE_POLICY: "{SitePermissions.SCOPE_POLICY}",
+  SCOPE_GLOBAL: "{SitePermissions.SCOPE_GLOBAL}",
+
+  // The delimiter used for double keyed permissions.
+  // For example: open-protocol-handler^irc
+  PERM_KEY_DELIMITER: "^",
+
+  _permissionsArray: null,
+  _defaultPrefBranch: Services.prefs.getBranch("permissions.default."),
+
+  // For testing use only.
+  _temporaryPermissions: TemporaryPermissions,
+
+  /**
+   * Gets all custom permissions for a given principal.
+   * Install addon permission is excluded, check bug 1303108.
+   *
+   * @return {Array} a list of objects with the keys:
+   *          - id: the permissionId of the permission
+   *          - scope: the scope of the permission (e.g. SitePermissions.SCOPE_TEMPORARY)
+   *          - state: a constant representing the current permission state
+   *            (e.g. SitePermissions.ALLOW)
+   */
+  getAllByPrincipal(principal) {
+    if (!principal) {
+      throw new Error("principal argument cannot be null.");
+    }
+    if (!this.isSupportedPrincipal(principal)) {
+      return [];
+    }
+
+    // Get all permissions from the permission manager by principal, excluding
+    // the ones set to be disabled.
+    let permissions = Services.perms
+      .getAllForPrincipal(principal)
+      .filter(permission => {
+        let entry = gPermissions.get(permission.type);
+        if (!entry || entry.disabled) {
+          return false;
+        }
+        let type = entry.id;
+
+        /* Hide persistent storage permission when extension principal
+         * have WebExtensions-unlimitedStorage permission. */
+        if (
+          type == "persistent-storage" &&
+          SitePermissions.getForPrincipal(
+            principal,
+            "WebExtensions-unlimitedStorage"
+          ).state == SitePermissions.ALLOW
+        ) {
+          return false;
+        }
+
+        return true;
+      });
+
+    return permissions.map(permission => {
+      let scope = this.SCOPE_PERSISTENT;
+      if (permission.expireType == Services.perms.EXPIRE_SESSION) {
+        scope = this.SCOPE_SESSION;
+      } else if (permission.expireType == Services.perms.EXPIRE_POLICY) {
+        scope = this.SCOPE_POLICY;
+      }
+
+      return {
+        id: permission.type,
+        scope,
+        state: permission.capability,
+      };
+    });
+  },
+
+  /**
+   * Returns all custom permissions for a given browser.
+   *
+   * To receive a more detailed, albeit less performant listing see
+   * SitePermissions.getAllPermissionDetailsForBrowser().
+   *
+   * @param {Browser} browser
+   *        The browser to fetch permission for.
+   *
+   * @return {Array} a list of objects with the keys:
+   *         - id: the permissionId of the permission
+   *         - state: a constant representing the current permission state
+   *           (e.g. SitePermissions.ALLOW)
+   *         - scope: a constant representing how long the permission will
+   *           be kept.
+   */
+  getAllForBrowser(browser) {
+    let permissions = {};
+
+    for (let permission of TemporaryPermissions.getAll(browser)) {
+      permission.scope = this.SCOPE_TEMPORARY;
+      permissions[permission.id] = permission;
+    }
+
+    for (let permission of GloballyBlockedPermissions.getAll(browser)) {
+      permissions[permission.id] = permission;
+    }
+
+    for (let permission of this.getAllByPrincipal(browser.contentPrincipal)) {
+      permissions[permission.id] = permission;
+    }
+
+    return Object.values(permissions);
+  },
+
+  /**
+   * Returns a list of objects with detailed information on all permissions
+   * that are currently set for the given browser.
+   *
+   * @param {Browser} browser
+   *        The browser to fetch permission for.
+   *
+   * @return {Array<Object>} a list of objects with the keys:
+   *           - id: the permissionID of the permission
+   *           - state: a constant representing the current permission state
+   *             (e.g. SitePermissions.ALLOW)
+   *           - scope: a constant representing how long the permission will
+   *             be kept.
+   *           - label: the localized label, or null if none is available.
+   */
+  getAllPermissionDetailsForBrowser(browser) {
+    return this.getAllForBrowser(browser).map(({ id, scope, state }) => ({
+      id,
+      scope,
+      state,
+      label: this.getPermissionLabel(id),
+    }));
+  },
+
+  /**
+   * Checks whether a UI for managing permissions should be exposed for a given
+   * principal.
+   *
+   * @param {nsIPrincipal} principal
+   *        The principal to check.
+   *
+   * @return {boolean} if the principal is supported.
+   */
+  isSupportedPrincipal(principal) {
+    if (!principal) {
+      return false;
+    }
+    if (!(principal instanceof Ci.nsIPrincipal)) {
+      throw new Error(
+        "Argument passed as principal is not an instance of Ci.nsIPrincipal"
+      );
+    }
+    return this.isSupportedScheme(principal.scheme);
+  },
+
+  /**
+   * Checks whether we support managing permissions for a specific scheme.
+   * @param {string} scheme - Scheme to test.
+   * @returns {boolean} Whether the scheme is supported.
+   */
+  isSupportedScheme(scheme) {
+    return ["http", "https", "moz-extension", "file"].includes(scheme);
+  },
+
+  /**
+   * Gets an array of all permission IDs.
+   *
+   * @return {Array<String>} an array of all permission IDs.
+   */
+  listPermissions() {
+    if (this._permissionsArray === null) {
+      this._permissionsArray = gPermissions.getEnabledPermissions();
+    }
+    return this._permissionsArray;
+  },
+
+  /**
+   * Test whether a permission is managed by SitePermissions.
+   * @param {string} type - Permission type.
+   * @returns {boolean}
+   */
+  isSitePermission(type) {
+    return gPermissions.has(type);
+  },
+
+  /**
+   * Called when a preference changes its value.
+   *
+   * @param {string} data
+   *        The last argument passed to the preference change observer
+   * @param {string} previous
+   *        The previous value of the preference
+   * @param {string} latest
+   *        The latest value of the preference
+   */
+  invalidatePermissionList(data, previous, latest) {
+    // Ensure that listPermissions() will reconstruct its return value the next
+    // time it's called.
+    this._permissionsArray = null;
+  },
+
+  /**
+   * Returns an array of permission states to be exposed to the user for a
+   * permission with the given ID.
+   *
+   * @param {string} permissionID
+   *        The ID to get permission states for.
+   *
+   * @return {Array<SitePermissions state>} an array of all permission states.
+   */
+  getAvailableStates(permissionID) {
+    if (
+      gPermissions.has(permissionID) &&
+      gPermissions.get(permissionID).states
+    ) {
+      return gPermissions.get(permissionID).states;
+    }
+
+    /* Since the permissions we are dealing with have adopted the convention
+     * of treating UNKNOWN == PROMPT, we only include one of either UNKNOWN
+     * or PROMPT in this list, to avoid duplicating states. */
+    if (this.getDefault(permissionID) == this.UNKNOWN) {
+      return [
+        SitePermissions.UNKNOWN,
+        SitePermissions.ALLOW,
+        SitePermissions.BLOCK,
+      ];
+    }
+
+    return [
+      SitePermissions.PROMPT,
+      SitePermissions.ALLOW,
+      SitePermissions.BLOCK,
+    ];
+  },
+
+  /**
+   * Returns the default state of a particular permission.
+   *
+   * @param {string} permissionID
+   *        The ID to get the default for.
+   *
+   * @return {SitePermissions.state} the default state.
+   */
+  getDefault(permissionID) {
+    // If the permission has custom logic for getting its default value,
+    // try that first.
+    if (
+      gPermissions.has(permissionID) &&
+      gPermissions.get(permissionID).getDefault
+    ) {
+      return gPermissions.get(permissionID).getDefault();
+    }
+
+    // Otherwise try to get the default preference for that permission.
+    return this._defaultPrefBranch.getIntPref(permissionID, this.UNKNOWN);
+  },
+
+  /**
+   * Set the default state of a particular permission.
+   *
+   * @param {string} permissionID
+   *        The ID to set the default for.
+   *
+   * @param {string} state
+   *        The state to set.
+   */
+  setDefault(permissionID, state) {
+    if (
+      gPermissions.has(permissionID) &&
+      gPermissions.get(permissionID).setDefault
+    ) {
+      return gPermissions.get(permissionID).setDefault(state);
+    }
+    let key = "permissions.default." + permissionID;
+    return Services.prefs.setIntPref(key, state);
+  },
+
+  /**
+   * Returns the state and scope of a particular permission for a given principal.
+   *
+   * This method will NOT dispatch a "PermissionStateChange" event on the specified
+   * browser if a temporary permission was removed because it has expired.
+   *
+   * @param {nsIPrincipal} principal
+   *        The principal to check.
+   * @param {String} permissionID
+   *        The id of the permission.
+   * @param {Browser} [browser] The browser object to check for temporary
+   *        permissions.
+   *
+   * @return {Object} an object with the keys:
+   *           - state: The current state of the permission
+   *             (e.g. SitePermissions.ALLOW)
+   *           - scope: The scope of the permission
+   *             (e.g. SitePermissions.SCOPE_PERSISTENT)
+   */
+  getForPrincipal(principal, permissionID, browser) {
+    if (!principal && !browser) {
+      throw new Error(
+        "Atleast one of the arguments, either principal or browser should not be null."
+      );
+    }
+    let defaultState = this.getDefault(permissionID);
+    let result = { state: defaultState, scope: this.SCOPE_PERSISTENT };
+    if (this.isSupportedPrincipal(principal)) {
+      let permission = null;
+      if (
+        gPermissions.has(permissionID) &&
+        gPermissions.get(permissionID).exactHostMatch
+      ) {
+        permission = Services.perms.getPermissionObject(
+          principal,
+          permissionID,
+          true
+        );
+      } else {
+        permission = Services.perms.getPermissionObject(
+          principal,
+          permissionID,
+          false
+        );
+      }
+
+      if (permission) {
+        result.state = permission.capability;
+        if (permission.expireType == Services.perms.EXPIRE_SESSION) {
+          result.scope = this.SCOPE_SESSION;
+        } else if (permission.expireType == Services.perms.EXPIRE_POLICY) {
+          result.scope = this.SCOPE_POLICY;
+        }
+      }
+    }
+
+    if (result.state == defaultState) {
+      // If there's no persistent permission saved, check if we have something
+      // set temporarily.
+      let value = TemporaryPermissions.get(browser, permissionID);
+
+      if (value) {
+        result.state = value.state;
+        result.scope = this.SCOPE_TEMPORARY;
+      }
+    }
+
+    return result;
+  },
+
+  /**
+   * Sets the state of a particular permission for a given principal or browser.
+   * This method will dispatch a "PermissionStateChange" event on the specified
+   * browser if a temporary permission was set
+   *
+   * @param {nsIPrincipal} [principal] The principal to set the permission for.
+   *        When setting temporary permissions passing a principal is optional.
+   *        If the principal is still passed here it takes precedence over the
+   *        browser's contentPrincipal for permission keying. This can be
+   *        helpful in situations where the browser has already navigated away
+   *        from a site you want to set a permission for.
+   * @param {String} permissionID The id of the permission.
+   * @param {SitePermissions state} state The state of the permission.
+   * @param {SitePermissions scope} [scope] The scope of the permission.
+   *        Defaults to SCOPE_PERSISTENT.
+   * @param {Browser} [browser] The browser object to set temporary permissions
+   *        on. This needs to be provided if the scope is SCOPE_TEMPORARY!
+   * @param {number} [expireTimeMS] If setting a temporary permission, how many
+   *        milliseconds it should be valid for. The default is controlled by
+   *        the 'privacy.temporary_permission_expire_time_ms' pref.
+   */
+  setForPrincipal(
+    principal,
+    permissionID,
+    state,
+    scope = this.SCOPE_PERSISTENT,
+    browser = null,
+    expireTimeMS = SitePermissions.temporaryPermissionExpireTime
+  ) {
+    if (!principal && !browser) {
+      throw new Error(
+        "Atleast one of the arguments, either principal or browser should not be null."
+      );
+    }
+    if (scope == this.SCOPE_GLOBAL && state == this.BLOCK) {
+      if (GloballyBlockedPermissions.set(browser, permissionID)) {
+        browser.dispatchEvent(
+          new browser.ownerGlobal.CustomEvent("PermissionStateChange")
+        );
+      }
+      return;
+    }
+
+    if (state == this.UNKNOWN || state == this.getDefault(permissionID)) {
+      // Because they are controlled by two prefs with many states that do not
+      // correspond to the classical ALLOW/DENY/PROMPT model, we want to always
+      // allow the user to add exceptions to their cookie rules without removing them.
+      if (permissionID != "cookie") {
+        this.removeFromPrincipal(principal, permissionID, browser);
+        return;
+      }
+    }
+
+    if (state == this.ALLOW_COOKIES_FOR_SESSION && permissionID != "cookie") {
+      throw new Error(
+        "ALLOW_COOKIES_FOR_SESSION can only be set on the cookie permission"
+      );
+    }
+
+    // Save temporary permissions.
+    if (scope == this.SCOPE_TEMPORARY) {
+      if (!browser) {
+        throw new Error(
+          "TEMPORARY scoped permissions require a browser object"
+        );
+      }
+      if (!Number.isInteger(expireTimeMS) || expireTimeMS <= 0) {
+        throw new Error("expireTime must be a positive integer");
+      }
+
+      if (
+        TemporaryPermissions.set(
+          browser,
+          permissionID,
+          state,
+          expireTimeMS,
+          principal ?? browser.contentPrincipal,
+          // On permission expiry
+          origBrowser => {
+            if (!origBrowser.ownerGlobal) {
+              return;
+            }
+            origBrowser.dispatchEvent(
+              new origBrowser.ownerGlobal.CustomEvent("PermissionStateChange")
+            );
+          }
+        )
+      ) {
+        browser.dispatchEvent(
+          new browser.ownerGlobal.CustomEvent("PermissionStateChange")
+        );
+      }
+    } else if (this.isSupportedPrincipal(principal)) {
+      let perms_scope = Services.perms.EXPIRE_NEVER;
+      if (scope == this.SCOPE_SESSION) {
+        perms_scope = Services.perms.EXPIRE_SESSION;
+      } else if (scope == this.SCOPE_POLICY) {
+        perms_scope = Services.perms.EXPIRE_POLICY;
+      }
+
+      Services.perms.addFromPrincipal(
+        principal,
+        permissionID,
+        state,
+        perms_scope
+      );
+    }
+  },
+
+  /**
+   * Removes the saved state of a particular permission for a given principal and/or browser.
+   * This method will dispatch a "PermissionStateChange" event on the specified
+   * browser if a temporary permission was removed.
+   *
+   * @param {nsIPrincipal} principal
+   *        The principal to remove the permission for.
+   * @param {String} permissionID
+   *        The id of the permission.
+   * @param {Browser} browser (optional)
+   *        The browser object to remove temporary permissions on.
+   */
+  removeFromPrincipal(principal, permissionID, browser) {
+    if (!principal && !browser) {
+      throw new Error(
+        "Atleast one of the arguments, either principal or browser should not be null."
+      );
+    }
+    if (this.isSupportedPrincipal(principal)) {
+      Services.perms.removeFromPrincipal(principal, permissionID);
+    }
+
+    // TemporaryPermissions.get() deletes expired permissions automatically,
+    // if it hasn't expired, remove it explicitly.
+    if (TemporaryPermissions.remove(browser, permissionID)) {
+      // Send a PermissionStateChange event only if the permission hasn't expired.
+      browser.dispatchEvent(
+        new browser.ownerGlobal.CustomEvent("PermissionStateChange")
+      );
+    }
+  },
+
+  /**
+   * Clears all block permissions that were temporarily saved.
+   *
+   * @param {Browser} browser
+   *        The browser object to clear.
+   */
+  clearTemporaryBlockPermissions(browser) {
+    TemporaryPermissions.clear(browser, SitePermissions.BLOCK);
+  },
+
+  /**
+   * Copy all permissions that were temporarily saved on one
+   * browser object to a new browser.
+   *
+   * @param {Browser} browser
+   *        The browser object to copy from.
+   * @param {Browser} newBrowser
+   *        The browser object to copy to.
+   */
+  copyTemporaryPermissions(browser, newBrowser) {
+    TemporaryPermissions.copy(browser, newBrowser);
+    GloballyBlockedPermissions.copy(browser, newBrowser);
+  },
+
+  /**
+   * Returns the localized label for the permission with the given ID, to be
+   * used in a UI for managing permissions.
+   * If a permission is double keyed (has an additional key in the ID), the
+   * second key is split off and supplied to the string formatter as a variable.
+   *
+   * @param {string} permissionID
+   *        The permission to get the label for. May include second key.
+   *
+   * @return {String} the localized label or null if none is available.
+   */
+  getPermissionLabel(permissionID) {
+    let [id, key] = permissionID.split(this.PERM_KEY_DELIMITER);
+    if (!gPermissions.has(id)) {
+      // Permission can't be found.
+      return null;
+    }
+    if (
+      "labelID" in gPermissions.get(id) &&
+      gPermissions.get(id).labelID === null
+    ) {
+      // Permission doesn't support having a label.
+      return null;
+    }
+    if (id == "3rdPartyStorage" || id == "3rdPartyFrameStorage") {
+      // The key is the 3rd party origin or site, which we use for the label.
+      return key;
+    }
+    let labelID = gPermissions.get(id).labelID || id;
+    return gStringBundle.formatStringFromName(`permission.${labelID}.label`, [
+      key,
+    ]);
+  },
+
+  /**
+   * Returns the localized label for the given permission state, to be used in
+   * a UI for managing permissions.
+   *
+   * @param {string} permissionID
+   *        The permission to get the label for.
+   *
+   * @param {SitePermissions state} state
+   *        The state to get the label for.
+   *
+   * @return {String|null} the localized label or null if an
+   *         unknown state was passed.
+   */
+  getMultichoiceStateLabel(permissionID, state) {
+    // If the permission has custom logic for getting its default value,
+    // try that first.
+    if (
+      gPermissions.has(permissionID) &&
+      gPermissions.get(permissionID).getMultichoiceStateLabel
+    ) {
+      return gPermissions.get(permissionID).getMultichoiceStateLabel(state);
+    }
+
+    switch (state) {
+      case this.UNKNOWN:
+      case this.PROMPT:
+        return gStringBundle.GetStringFromName("state.multichoice.alwaysAsk");
+      case this.ALLOW:
+        return gStringBundle.GetStringFromName("state.multichoice.allow");
+      case this.ALLOW_COOKIES_FOR_SESSION:
+        return gStringBundle.GetStringFromName(
+          "state.multichoice.allowForSession"
+        );
+      case this.BLOCK:
+        return gStringBundle.GetStringFromName("state.multichoice.block");
+      default:
+        return null;
+    }
+  },
+
+  /**
+   * Returns the localized label for a permission's current state.
+   *
+   * @param {SitePermissions state} state
+   *        The state to get the label for.
+   * @param {string} id
+   *        The permission to get the state label for.
+   * @param {SitePermissions scope} scope (optional)
+   *        The scope to get the label for.
+   *
+   * @return {String|null} the localized label or null if an
+   *         unknown state was passed.
+   */
+  getCurrentStateLabel(state, id, scope = null) {
+    switch (state) {
+      case this.PROMPT:
+        return gStringBundle.GetStringFromName("state.current.prompt");
+      case this.ALLOW:
+        if (
+          scope &&
+          scope != this.SCOPE_PERSISTENT &&
+          scope != this.SCOPE_POLICY
+        ) {
+          return gStringBundle.GetStringFromName(
+            "state.current.allowedTemporarily"
+          );
+        }
+        return gStringBundle.GetStringFromName("state.current.allowed");
+      case this.ALLOW_COOKIES_FOR_SESSION:
+        return gStringBundle.GetStringFromName(
+          "state.current.allowedForSession"
+        );
+      case this.BLOCK:
+        if (
+          scope &&
+          scope != this.SCOPE_PERSISTENT &&
+          scope != this.SCOPE_POLICY &&
+          scope != this.SCOPE_GLOBAL
+        ) {
+          return gStringBundle.GetStringFromName(
+            "state.current.blockedTemporarily"
+          );
+        }
+        return gStringBundle.GetStringFromName("state.current.blocked");
+      default:
+        return null;
+    }
+  },
+};
+
+let gPermissions = {
+  _getId(type) {
+    // Split off second key (if it exists).
+    let [id] = type.split(SitePermissions.PERM_KEY_DELIMITER);
+    return id;
+  },
+
+  has(type) {
+    return this._getId(type) in this._permissions;
+  },
+
+  get(type) {
+    let id = this._getId(type);
+    let perm = this._permissions[id];
+    if (perm) {
+      perm.id = id;
+    }
+    return perm;
+  },
+
+  getEnabledPermissions() {
+    return Object.keys(this._permissions).filter(
+      id => !this._permissions[id].disabled
+    );
+  },
+
+  /* Holds permission ID => options pairs.
+   *
+   * Supported options:
+   *
+   *  - exactHostMatch
+   *    Allows sub domains to have their own permissions.
+   *    Defaults to false.
+   *
+   *  - getDefault
+   *    Called to get the permission's default state.
+   *    Defaults to UNKNOWN, indicating that the user will be asked each time
+   *    a page asks for that permissions.
+   *
+   *  - labelID
+   *    Use the given ID instead of the permission name for looking up strings.
+   *    e.g. "desktop-notification2" to use permission.desktop-notification2.label
+   *
+   *  - states
+   *    Array of permission states to be exposed to the user.
+   *    Defaults to ALLOW, BLOCK and the default state (see getDefault).
+   *
+   *  - getMultichoiceStateLabel
+   *    Optional method to overwrite SitePermissions#getMultichoiceStateLabel with custom label logic.
+   */
+  _permissions: {
+    "autoplay-media": {
+      exactHostMatch: true,
+      getDefault() {
+        let pref = Services.prefs.getIntPref(
+          "media.autoplay.default",
+          Ci.nsIAutoplay.BLOCKED
+        );
+        if (pref == Ci.nsIAutoplay.ALLOWED) {
+          return SitePermissions.ALLOW;
+        }
+        if (pref == Ci.nsIAutoplay.BLOCKED_ALL) {
+          return SitePermissions.AUTOPLAY_BLOCKED_ALL;
+        }
+        return SitePermissions.BLOCK;
+      },
+      setDefault(value) {
+        let prefValue = Ci.nsIAutoplay.BLOCKED;
+        if (value == SitePermissions.ALLOW) {
+          prefValue = Ci.nsIAutoplay.ALLOWED;
+        } else if (value == SitePermissions.AUTOPLAY_BLOCKED_ALL) {
+          prefValue = Ci.nsIAutoplay.BLOCKED_ALL;
+        }
+        Services.prefs.setIntPref("media.autoplay.default", prefValue);
+      },
+      labelID: "autoplay",
+      states: [
+        SitePermissions.ALLOW,
+        SitePermissions.BLOCK,
+        SitePermissions.AUTOPLAY_BLOCKED_ALL,
+      ],
+      getMultichoiceStateLabel(state) {
+        switch (state) {
+          case SitePermissions.AUTOPLAY_BLOCKED_ALL:
+            return gStringBundle.GetStringFromName(
+              "state.multichoice.autoplayblockall"
+            );
+          case SitePermissions.BLOCK:
+            return gStringBundle.GetStringFromName(
+              "state.multichoice.autoplayblock"
+            );
+          case SitePermissions.ALLOW:
+            return gStringBundle.GetStringFromName(
+              "state.multichoice.autoplayallow"
+            );
+        }
+        throw new Error(`Unknown state: ${state}`);
+      },
+    },
+
+    cookie: {
+      states: [
+        SitePermissions.ALLOW,
+        SitePermissions.ALLOW_COOKIES_FOR_SESSION,
+        SitePermissions.BLOCK,
+      ],
+      getDefault() {
+        if (
+          Services.cookies.getCookieBehavior(false) ==
+          Ci.nsICookieService.BEHAVIOR_REJECT
+        ) {
+          return SitePermissions.BLOCK;
+        }
+
+        return SitePermissions.ALLOW;
+      },
+    },
+
+    "desktop-notification": {
+      exactHostMatch: true,
+      labelID: "desktop-notification3",
+    },
+
+    camera: {
+      exactHostMatch: true,
+    },
+
+    microphone: {
+      exactHostMatch: true,
+    },
+
+    screen: {
+      exactHostMatch: true,
+      states: [SitePermissions.UNKNOWN, SitePermissions.BLOCK],
+    },
+
+    speaker: {
+      exactHostMatch: true,
+      states: [SitePermissions.UNKNOWN, SitePermissions.BLOCK],
+      get disabled() {
+        return !SitePermissions.setSinkIdEnabled;
+      },
+    },
+
+    popup: {
+      getDefault() {
+        return Services.prefs.getBoolPref("dom.disable_open_during_load")
+          ? SitePermissions.BLOCK
+          : SitePermissions.ALLOW;
+      },
+      states: [SitePermissions.ALLOW, SitePermissions.BLOCK],
+    },
+
+    install: {
+      getDefault() {
+        return Services.prefs.getBoolPref("xpinstall.whitelist.required")
+          ? SitePermissions.UNKNOWN
+          : SitePermissions.ALLOW;
+      },
+    },
+
+    geo: {
+      exactHostMatch: true,
+    },
+
+    "open-protocol-handler": {
+      labelID: "open-protocol-handler",
+      exactHostMatch: true,
+      states: [SitePermissions.UNKNOWN, SitePermissions.ALLOW],
+      get disabled() {
+        return !SitePermissions.openProtoPermissionEnabled;
+      },
+    },
+
+    xr: {
+      exactHostMatch: true,
+    },
+
+    "focus-tab-by-prompt": {
+      exactHostMatch: true,
+      states: [SitePermissions.UNKNOWN, SitePermissions.ALLOW],
+    },
+    "persistent-storage": {
+      exactHostMatch: true,
+    },
+
+    shortcuts: {
+      states: [SitePermissions.ALLOW, SitePermissions.BLOCK],
+    },
+
+    canvas: {
+      get disabled() {
+        return !SitePermissions.resistFingerprinting;
+      },
+    },
+
+    midi: {
+      exactHostMatch: true,
+      get disabled() {
+        return !SitePermissions.midiPermissionEnabled;
+      },
+    },
+
+    "midi-sysex": {
+      exactHostMatch: true,
+      get disabled() {
+        return !SitePermissions.midiPermissionEnabled;
+      },
+    },
+
+    "storage-access": {
+      labelID: null,
+      getDefault() {
+        return SitePermissions.UNKNOWN;
+      },
+    },
+
+    "3rdPartyStorage": {},
+    "3rdPartyFrameStorage": {},
+  },
+};
+
+SitePermissions.midiPermissionEnabled = Services.prefs.getBoolPref(
+  "dom.webmidi.enabled"
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  SitePermissions,
+  "temporaryPermissionExpireTime",
+  "privacy.temporary_permission_expire_time_ms",
+  3600 * 1000
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  SitePermissions,
+  "setSinkIdEnabled",
+  "media.setsinkid.enabled",
+  false,
+  SitePermissions.invalidatePermissionList.bind(SitePermissions)
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  SitePermissions,
+  "resistFingerprinting",
+  "privacy.resistFingerprinting",
+  false,
+  SitePermissions.invalidatePermissionList.bind(SitePermissions)
+);
+XPCOMUtils.defineLazyPreferenceGetter(
+  SitePermissions,
+  "openProtoPermissionEnabled",
+  "security.external_protocol_requires_permission",
+  true,
+  SitePermissions.invalidatePermissionList.bind(SitePermissions)
+);
diff --git a/browser/modules/TabUnloader.sys.mjs b/browser/modules/TabUnloader.sys.mjs
new file mode 100644
index 0000000000..a0c1233f27
--- /dev/null
+++ b/browser/modules/TabUnloader.sys.mjs
@@ -0,0 +1,515 @@
+/* -*- mode: js; indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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/. */
+
+/*
+ * TabUnloader is used to discard tabs when memory or resource constraints
+ * are reached. The discarded tabs are determined using a heuristic that
+ * accounts for when the tab was last used, how many resources the tab uses,
+ * and whether the tab is likely to affect the user if it is closed.
+ */
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  webrtcUI: "resource:///modules/webrtcUI.sys.mjs",
+});
+
+// If there are only this many or fewer tabs open, just sort by weight, and close
+// the lowest tab. Otherwise, do a more intensive compuation that determines the
+// tabs to close based on memory and process use.
+const MIN_TABS_COUNT = 10;
+
+// Weight for non-discardable tabs.
+const NEVER_DISCARD = 100000;
+
+// Default minimum inactive duration.  Tabs that were accessed in the last
+// period of this duration are not unloaded.
+const kMinInactiveDurationInMs = Services.prefs.getIntPref(
+  "browser.tabs.min_inactive_duration_before_unload"
+);
+
+let criteriaTypes = [
+  ["isNonDiscardable", NEVER_DISCARD],
+  ["isLoading", 8],
+  ["usingPictureInPicture", NEVER_DISCARD],
+  ["playingMedia", NEVER_DISCARD],
+  ["usingWebRTC", NEVER_DISCARD],
+  ["isPinned", 2],
+  ["isPrivate", NEVER_DISCARD],
+];
+
+// Indicies into the criteriaTypes lists.
+let CRITERIA_METHOD = 0;
+let CRITERIA_WEIGHT = 1;
+
+/**
+ * This is an object that supplies methods that determine details about
+ * each tab. This default object is used if another one is not passed
+ * to the tab unloader functions. This allows tests to override the methods
+ * with tab specific data rather than creating test tabs.
+ */
+let DefaultTabUnloaderMethods = {
+  isNonDiscardable(tab, weight) {
+    if (tab.undiscardable || tab.selected) {
+      return weight;
+    }
+
+    return !tab.linkedBrowser.isConnected ? -1 : 0;
+  },
+
+  isPinned(tab, weight) {
+    return tab.pinned ? weight : 0;
+  },
+
+  isLoading(tab, weight) {
+    return 0;
+  },
+
+  usingPictureInPicture(tab, weight) {
+    // This has higher weight even when paused.
+    return tab.pictureinpicture ? weight : 0;
+  },
+
+  playingMedia(tab, weight) {
+    return tab.soundPlaying ? weight : 0;
+  },
+
+  usingWebRTC(tab, weight) {
+    const browser = tab.linkedBrowser;
+    if (!browser) {
+      return 0;
+    }
+
+    // No need to iterate browser contexts for hasActivePeerConnection
+    // because hasActivePeerConnection is set only in the top window.
+    return lazy.webrtcUI.browserHasStreams(browser) ||
+      browser.browsingContext?.currentWindowGlobal?.hasActivePeerConnections()
+      ? weight
+      : 0;
+  },
+
+  isPrivate(tab, weight) {
+    return lazy.PrivateBrowsingUtils.isBrowserPrivate(tab.linkedBrowser)
+      ? weight
+      : 0;
+  },
+
+  getMinTabCount() {
+    return MIN_TABS_COUNT;
+  },
+
+  getNow() {
+    return Date.now();
+  },
+
+  *iterateTabs() {
+    for (let win of Services.wm.getEnumerator("navigator:browser")) {
+      for (let tab of win.gBrowser.tabs) {
+        yield { tab, gBrowser: win.gBrowser };
+      }
+    }
+  },
+
+  *iterateBrowsingContexts(bc) {
+    yield bc;
+    for (let childBC of bc.children) {
+      yield* this.iterateBrowsingContexts(childBC);
+    }
+  },
+
+  *iterateProcesses(tab) {
+    let bc = tab?.linkedBrowser?.browsingContext;
+    if (!bc) {
+      return;
+    }
+
+    const iter = this.iterateBrowsingContexts(bc);
+    for (let childBC of iter) {
+      if (childBC?.currentWindowGlobal) {
+        yield childBC.currentWindowGlobal.osPid;
+      }
+    }
+  },
+
+  /**
+   * Add the amount of memory used by each process to the process map.
+   *
+   * @param tabs array of tabs, used only by unit tests
+   * @param map of processes returned by getAllProcesses.
+   */
+  async calculateMemoryUsage(processMap) {
+    let parentProcessInfo = await ChromeUtils.requestProcInfo();
+    let childProcessInfoList = parentProcessInfo.children;
+    for (let childProcInfo of childProcessInfoList) {
+      let processInfo = processMap.get(childProcInfo.pid);
+      if (!processInfo) {
+        processInfo = { count: 0, topCount: 0, tabSet: new Set() };
+        processMap.set(childProcInfo.pid, processInfo);
+      }
+      processInfo.memory = childProcInfo.memory;
+    }
+  },
+};
+
+/**
+ * This module is responsible for detecting low-memory scenarios and unloading
+ * tabs in response to them.
+ */
+
+export var TabUnloader = {
+  /**
+   * Initialize low-memory detection and tab auto-unloading.
+   */
+  init() {
+    const watcher = Cc["@mozilla.org/xpcom/memory-watcher;1"].getService(
+      Ci.nsIAvailableMemoryWatcherBase
+    );
+    watcher.registerTabUnloader(this);
+  },
+
+  isDiscardable(tab) {
+    if (!("weight" in tab)) {
+      return false;
+    }
+    return tab.weight < NEVER_DISCARD;
+  },
+
+  // This method is exposed on nsITabUnloader
+  async unloadTabAsync(minInactiveDuration = kMinInactiveDurationInMs) {
+    const watcher = Cc["@mozilla.org/xpcom/memory-watcher;1"].getService(
+      Ci.nsIAvailableMemoryWatcherBase
+    );
+
+    if (!Services.prefs.getBoolPref("browser.tabs.unloadOnLowMemory", true)) {
+      watcher.onUnloadAttemptCompleted(Cr.NS_ERROR_NOT_AVAILABLE);
+      return;
+    }
+
+    if (this._isUnloading) {
+      // Don't post multiple unloading requests.  The situation may be solved
+      // when the active unloading task is completed.
+      Services.console.logStringMessage("Unloading a tab is in progress.");
+      watcher.onUnloadAttemptCompleted(Cr.NS_ERROR_ABORT);
+      return;
+    }
+
+    this._isUnloading = true;
+    const isTabUnloaded = await this.unloadLeastRecentlyUsedTab(
+      minInactiveDuration
+    );
+    this._isUnloading = false;
+
+    watcher.onUnloadAttemptCompleted(
+      isTabUnloaded ? Cr.NS_OK : Cr.NS_ERROR_NOT_AVAILABLE
+    );
+  },
+
+  /**
+   * Get a list of tabs that can be discarded. This list includes all tabs in
+   * all windows and is sorted based on a weighting described below.
+   *
+   * @param minInactiveDuration If this value is a number, tabs that were accessed
+   *        in the last |minInactiveDuration| msec are not unloaded even if they
+   *        are least-recently-used.
+   *
+   * @param tabMethods an helper object with methods called by this algorithm.
+   *
+   * The algorithm used is:
+   *   1. Sort all of the tabs by a base weight. Tabs with a higher weight, such as
+   *      those that are pinned or playing audio, will appear at the end. When two
+   *      tabs have the same weight, sort by the order in which they were last.
+   *      recently accessed Tabs that have a weight of NEVER_DISCARD are included in
+   *       the list, but will not be discarded.
+   *   2. Exclude the last X tabs, where X is the value returned by getMinTabCount().
+   *      These tabs are considered to have been recently accessed and are not further
+   *      reweighted. This also saves time when there are less than X tabs open.
+   *   3. Calculate the amount of processes that are used only by each tab, as the
+   *      resources used by these proceses can be freed up if the tab is closed. Sort
+   *      the tabs by the number of unique processes used and add a reweighting factor
+   *      based on this.
+   *   4. Futher reweight based on an approximation of the amount of memory that each
+   *      tab uses.
+   *   5. Combine these weights to produce a final tab discard order, and discard the
+   *      first tab. If this fails, then discard the next tab in the list until no more
+   *      non-discardable tabs are found.
+   *
+   * The tabMethods are used so that unit tests can use false tab objects and
+   * override their behaviour.
+   */
+  async getSortedTabs(
+    minInactiveDuration = kMinInactiveDurationInMs,
+    tabMethods = DefaultTabUnloaderMethods
+  ) {
+    let tabs = [];
+
+    const now = tabMethods.getNow();
+
+    let lowestWeight = 1000;
+    for (let tab of tabMethods.iterateTabs()) {
+      if (
+        typeof minInactiveDuration == "number" &&
+        now - tab.tab.lastAccessed < minInactiveDuration
+      ) {
+        // Skip "fresh" tabs, which were accessed within the specified duration.
+        continue;
+      }
+
+      let weight = determineTabBaseWeight(tab, tabMethods);
+
+      // Don't add tabs that have a weight of -1.
+      if (weight != -1) {
+        tab.weight = weight;
+        tabs.push(tab);
+        if (weight < lowestWeight) {
+          lowestWeight = weight;
+        }
+      }
+    }
+
+    tabs = tabs.sort((a, b) => {
+      if (a.weight != b.weight) {
+        return a.weight - b.weight;
+      }
+
+      return a.tab.lastAccessed - b.tab.lastAccessed;
+    });
+
+    // If the lowest priority tab is not discardable, no need to continue.
+    if (!tabs.length || !this.isDiscardable(tabs[0])) {
+      return tabs;
+    }
+
+    // Determine the lowest weight that the tabs have. The tabs with the
+    // lowest weight (should be most non-selected tabs) will be additionally
+    // weighted by the number of processes and memory that they use.
+    let higherWeightedCount = 0;
+    for (let idx = 0; idx < tabs.length; idx++) {
+      if (tabs[idx].weight != lowestWeight) {
+        higherWeightedCount = tabs.length - idx;
+        break;
+      }
+    }
+
+    // Don't continue to reweight the last few tabs, the number of which is
+    // determined by getMinTabCount. This prevents extra work when there are
+    // only a few tabs, or for the last few tabs that have likely been used
+    // recently.
+    let minCount = tabMethods.getMinTabCount();
+    if (higherWeightedCount < minCount) {
+      higherWeightedCount = minCount;
+    }
+
+    // If |lowestWeightedCount| is 1, no benefit from calculating
+    // the tab's memory and additional weight.
+    const lowestWeightedCount = tabs.length - higherWeightedCount;
+    if (lowestWeightedCount > 1) {
+      let processMap = getAllProcesses(tabs, tabMethods);
+
+      let higherWeightedTabs = tabs.splice(-higherWeightedCount);
+
+      await adjustForResourceUse(tabs, processMap, tabMethods);
+      tabs = tabs.concat(higherWeightedTabs);
+    }
+
+    return tabs;
+  },
+
+  /**
+   * Select and discard one tab.
+   * @returns true if a tab was unloaded, otherwise false.
+   */
+  async unloadLeastRecentlyUsedTab(
+    minInactiveDuration = kMinInactiveDurationInMs
+  ) {
+    const sortedTabs = await this.getSortedTabs(minInactiveDuration);
+
+    for (let tabInfo of sortedTabs) {
+      if (!this.isDiscardable(tabInfo)) {
+        // Since |sortedTabs| is sorted, once we see an undiscardable tab
+        // no need to continue the loop.
+        return false;
+      }
+
+      const remoteType = tabInfo.tab?.linkedBrowser?.remoteType;
+      if (tabInfo.gBrowser.discardBrowser(tabInfo.tab)) {
+        Services.console.logStringMessage(
+          `TabUnloader discarded <${remoteType}>`
+        );
+        tabInfo.tab.updateLastUnloadedByTabUnloader();
+        return true;
+      }
+    }
+    return false;
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIObserver",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+/** Determine the base weight of the tab without accounting for
+ *  resource use
+ * @param tab tab to use
+ * @returns the tab's base weight
+ */
+function determineTabBaseWeight(tab, tabMethods) {
+  let totalWeight = 0;
+
+  for (let criteriaType of criteriaTypes) {
+    let weight = tabMethods[criteriaType[CRITERIA_METHOD]](
+      tab.tab,
+      criteriaType[CRITERIA_WEIGHT]
+    );
+
+    // If a criteria returns -1, then never discard this tab.
+    if (weight == -1) {
+      return -1;
+    }
+
+    totalWeight += weight;
+  }
+
+  return totalWeight;
+}
+
+/**
+ * Constuct a map of the processes that are used by the supplied tabs.
+ * The map will map process ids to an object with two properties:
+ *   count - the number of tabs or subframes that use this process
+ *   topCount - the number of top-level tabs that use this process
+ *   tabSet - the indices of the tabs hosted by this process
+ *
+ * @param tabs array of tabs
+ * @param tabMethods an helper object with methods called by this algorithm.
+ * @returns process map
+ */
+function getAllProcesses(tabs, tabMethods) {
+  // Determine the number of tabs that reference each process. This
+  // is stored in the map 'processMap' where the key is the process
+  // and the value is that number of browsing contexts that use that
+  // process.
+  // XXXndeakin this should be unique processes per tab, in the case multiple
+  // subframes use the same process?
+
+  let processMap = new Map();
+
+  for (let tabIndex = 0; tabIndex < tabs.length; ++tabIndex) {
+    const tab = tabs[tabIndex];
+
+    // The per-tab map will map process ids to an object with three properties:
+    //   isTopLevel - whether the process hosts the tab's top-level frame or not
+    //   frameCount - the number of frames hosted by the process
+    //                (a top frame contributes 2 and a sub frame contributes 1)
+    //   entryToProcessMap - the reference to the object in |processMap|
+    tab.processes = new Map();
+
+    let topLevel = true;
+    for (let pid of tabMethods.iterateProcesses(tab.tab)) {
+      let processInfo = processMap.get(pid);
+      if (processInfo) {
+        processInfo.count++;
+        processInfo.tabSet.add(tabIndex);
+      } else {
+        processInfo = { count: 1, topCount: 0, tabSet: new Set([tabIndex]) };
+        processMap.set(pid, processInfo);
+      }
+
+      let tabProcessEntry = tab.processes.get(pid);
+      if (tabProcessEntry) {
+        ++tabProcessEntry.frameCount;
+      } else {
+        tabProcessEntry = {
+          isTopLevel: topLevel,
+          frameCount: 1,
+          entryToProcessMap: processInfo,
+        };
+        tab.processes.set(pid, tabProcessEntry);
+      }
+
+      if (topLevel) {
+        topLevel = false;
+        processInfo.topCount = processInfo.topCount
+          ? processInfo.topCount + 1
+          : 1;
+        // top-level frame contributes two frame counts
+        ++tabProcessEntry.frameCount;
+      }
+    }
+  }
+
+  return processMap;
+}
+
+/**
+ * Adjust the tab info and reweight the tabs based on the process and memory
+ * use that is used, as described by getSortedTabs
+
+ * @param tabs array of tabs
+ * @param processMap map of processes returned by getAllProcesses
+ * @param tabMethods an helper object with methods called by this algorithm.
+ */
+async function adjustForResourceUse(tabs, processMap, tabMethods) {
+  // The second argument is needed for testing.
+  await tabMethods.calculateMemoryUsage(processMap, tabs);
+
+  let sortWeight = 0;
+  for (let tab of tabs) {
+    tab.sortWeight = ++sortWeight;
+
+    let uniqueCount = 0;
+    let totalMemory = 0;
+    for (const procEntry of tab.processes.values()) {
+      const processInfo = procEntry.entryToProcessMap;
+      if (processInfo.tabSet.size == 1) {
+        uniqueCount++;
+      }
+
+      // Guess how much memory the frame might be using using by dividing
+      // the total memory used by a process by the number of tabs and
+      // frames that are using that process. Assume that any subframes take up
+      // only half as much memory as a process loaded in a top level tab.
+      // So for example, if a process is used in four top level tabs and two
+      // subframes, the top level tabs share 80% of the memory and the subframes
+      // use 20% of the memory.
+      const perFrameMemory =
+        processInfo.memory /
+        (processInfo.topCount * 2 + (processInfo.count - processInfo.topCount));
+      totalMemory += perFrameMemory * procEntry.frameCount;
+    }
+
+    tab.uniqueCount = uniqueCount;
+    tab.memory = totalMemory;
+  }
+
+  tabs.sort((a, b) => {
+    return b.uniqueCount - a.uniqueCount;
+  });
+  sortWeight = 0;
+  for (let tab of tabs) {
+    tab.sortWeight += ++sortWeight;
+    if (tab.uniqueCount > 1) {
+      // If the tab has a number of processes that are only used by this tab,
+      // subtract off an additional amount to the sorting weight value. That
+      // way, tabs that use lots of processes are more likely to be discarded.
+      tab.sortWeight -= tab.uniqueCount - 1;
+    }
+  }
+
+  tabs.sort((a, b) => {
+    return b.memory - a.memory;
+  });
+  sortWeight = 0;
+  for (let tab of tabs) {
+    tab.sortWeight += ++sortWeight;
+  }
+
+  tabs.sort((a, b) => {
+    if (a.sortWeight != b.sortWeight) {
+      return a.sortWeight - b.sortWeight;
+    }
+    return a.tab.lastAccessed - b.tab.lastAccessed;
+  });
+}
diff --git a/browser/modules/TabsList.sys.mjs b/browser/modules/TabsList.sys.mjs
new file mode 100644
index 0000000000..9e6c36f4a8
--- /dev/null
+++ b/browser/modules/TabsList.sys.mjs
@@ -0,0 +1,573 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PanelMultiView: "resource:///modules/PanelMultiView.sys.mjs",
+});
+
+const TAB_DROP_TYPE = "application/x-moz-tabbrowser-tab";
+
+function setAttributes(element, attrs) {
+  for (let [name, value] of Object.entries(attrs)) {
+    if (value) {
+      element.setAttribute(name, value);
+    } else {
+      element.removeAttribute(name);
+    }
+  }
+}
+
+class TabsListBase {
+  constructor({
+    className,
+    filterFn,
+    insertBefore,
+    containerNode,
+    dropIndicator = null,
+  }) {
+    this.className = className;
+    this.filterFn = filterFn;
+    this.insertBefore = insertBefore;
+    this.containerNode = containerNode;
+    this.dropIndicator = dropIndicator;
+
+    if (this.dropIndicator) {
+      this.dropTargetRow = null;
+      this.dropTargetDirection = 0;
+    }
+
+    this.doc = containerNode.ownerDocument;
+    this.gBrowser = this.doc.defaultView.gBrowser;
+    this.tabToElement = new Map();
+    this.listenersRegistered = false;
+  }
+
+  get rows() {
+    return this.tabToElement.values();
+  }
+
+  handleEvent(event) {
+    switch (event.type) {
+      case "TabAttrModified":
+        this._tabAttrModified(event.target);
+        break;
+      case "TabClose":
+        this._tabClose(event.target);
+        break;
+      case "TabMove":
+        this._moveTab(event.target);
+        break;
+      case "TabPinned":
+        if (!this.filterFn(event.target)) {
+          this._tabClose(event.target);
+        }
+        break;
+      case "command":
+        this._selectTab(event.target.tab);
+        break;
+      case "dragstart":
+        this._onDragStart(event);
+        break;
+      case "dragover":
+        this._onDragOver(event);
+        break;
+      case "dragleave":
+        this._onDragLeave(event);
+        break;
+      case "dragend":
+        this._onDragEnd(event);
+        break;
+      case "drop":
+        this._onDrop(event);
+        break;
+      case "click":
+        this._onClick(event);
+        break;
+    }
+  }
+
+  _selectTab(tab) {
+    if (this.gBrowser.selectedTab != tab) {
+      this.gBrowser.selectedTab = tab;
+    } else {
+      this.gBrowser.tabContainer._handleTabSelect();
+    }
+  }
+
+  /*
+   * Populate the popup with menuitems and setup the listeners.
+   */
+  _populate(event) {
+    let fragment = this.doc.createDocumentFragment();
+
+    for (let tab of this.gBrowser.tabs) {
+      if (this.filterFn(tab)) {
+        fragment.appendChild(this._createRow(tab));
+      }
+    }
+
+    this._addElement(fragment);
+    this._setupListeners();
+  }
+
+  _addElement(elementOrFragment) {
+    this.containerNode.insertBefore(elementOrFragment, this.insertBefore);
+  }
+
+  /*
+   * Remove the menuitems from the DOM, cleanup internal state and listeners.
+   */
+  _cleanup() {
+    for (let item of this.rows) {
+      item.remove();
+    }
+    this.tabToElement = new Map();
+    this._cleanupListeners();
+    this._clearDropTarget();
+  }
+
+  _setupListeners() {
+    this.listenersRegistered = true;
+
+    this.gBrowser.tabContainer.addEventListener("TabAttrModified", this);
+    this.gBrowser.tabContainer.addEventListener("TabClose", this);
+    this.gBrowser.tabContainer.addEventListener("TabMove", this);
+    this.gBrowser.tabContainer.addEventListener("TabPinned", this);
+
+    this.containerNode.addEventListener("click", this);
+
+    if (this.dropIndicator) {
+      this.containerNode.addEventListener("dragstart", this);
+      this.containerNode.addEventListener("dragover", this);
+      this.containerNode.addEventListener("dragleave", this);
+      this.containerNode.addEventListener("dragend", this);
+      this.containerNode.addEventListener("drop", this);
+    }
+  }
+
+  _cleanupListeners() {
+    this.gBrowser.tabContainer.removeEventListener("TabAttrModified", this);
+    this.gBrowser.tabContainer.removeEventListener("TabClose", this);
+    this.gBrowser.tabContainer.removeEventListener("TabMove", this);
+    this.gBrowser.tabContainer.removeEventListener("TabPinned", this);
+
+    this.containerNode.removeEventListener("click", this);
+
+    if (this.dropIndicator) {
+      this.containerNode.removeEventListener("dragstart", this);
+      this.containerNode.removeEventListener("dragover", this);
+      this.containerNode.removeEventListener("dragleave", this);
+      this.containerNode.removeEventListener("dragend", this);
+      this.containerNode.removeEventListener("drop", this);
+    }
+
+    this.listenersRegistered = false;
+  }
+
+  _tabAttrModified(tab) {
+    let item = this.tabToElement.get(tab);
+    if (item) {
+      if (!this.filterFn(tab)) {
+        // The tab no longer matches our criteria, remove it.
+        this._removeItem(item, tab);
+      } else {
+        this._setRowAttributes(item, tab);
+      }
+    } else if (this.filterFn(tab)) {
+      // The tab now matches our criteria, add a row for it.
+      this._addTab(tab);
+    }
+  }
+
+  _moveTab(tab) {
+    let item = this.tabToElement.get(tab);
+    if (item) {
+      this._removeItem(item, tab);
+      this._addTab(tab);
+    }
+  }
+  _addTab(newTab) {
+    if (!this.filterFn(newTab)) {
+      return;
+    }
+    let newRow = this._createRow(newTab);
+    let nextTab = newTab.nextElementSibling;
+
+    while (nextTab && !this.filterFn(nextTab)) {
+      nextTab = nextTab.nextElementSibling;
+    }
+
+    // If we found a tab after this one in the list, insert the new row before it.
+    let nextRow = this.tabToElement.get(nextTab);
+    if (nextRow) {
+      nextRow.parentNode.insertBefore(newRow, nextRow);
+    } else {
+      // If there's no next tab then insert it as usual.
+      this._addElement(newRow);
+    }
+  }
+  _tabClose(tab) {
+    let item = this.tabToElement.get(tab);
+    if (item) {
+      this._removeItem(item, tab);
+    }
+  }
+
+  _removeItem(item, tab) {
+    this.tabToElement.delete(tab);
+    item.remove();
+  }
+}
+
+const TABS_PANEL_EVENTS = {
+  show: "ViewShowing",
+  hide: "PanelMultiViewHidden",
+};
+
+export class TabsPanel extends TabsListBase {
+  constructor(opts) {
+    super({
+      ...opts,
+      containerNode: opts.containerNode || opts.view.firstElementChild,
+    });
+    this.view = opts.view;
+    this.view.addEventListener(TABS_PANEL_EVENTS.show, this);
+    this.panelMultiView = null;
+  }
+
+  handleEvent(event) {
+    switch (event.type) {
+      case TABS_PANEL_EVENTS.hide:
+        if (event.target == this.panelMultiView) {
+          this._cleanup();
+          this.panelMultiView = null;
+        }
+        break;
+      case TABS_PANEL_EVENTS.show:
+        if (!this.listenersRegistered && event.target == this.view) {
+          this.panelMultiView = this.view.panelMultiView;
+          this._populate(event);
+          this.gBrowser.translateTabContextMenu();
+        }
+        break;
+      case "command":
+        if (event.target.classList.contains("all-tabs-mute-button")) {
+          event.target.tab.toggleMuteAudio();
+          break;
+        }
+        if (event.target.classList.contains("all-tabs-close-button")) {
+          this.gBrowser.removeTab(event.target.tab);
+          break;
+        }
+      // fall through
+      default:
+        super.handleEvent(event);
+        break;
+    }
+  }
+
+  _populate(event) {
+    super._populate(event);
+
+    // The loading throbber can't be set until the toolbarbutton is rendered,
+    // so set the image attributes again now that the elements are in the DOM.
+    for (let row of this.rows) {
+      this._setImageAttributes(row, row.tab);
+    }
+  }
+
+  _selectTab(tab) {
+    super._selectTab(tab);
+    lazy.PanelMultiView.hidePopup(this.view.closest("panel"));
+  }
+
+  _setupListeners() {
+    super._setupListeners();
+    this.panelMultiView.addEventListener(TABS_PANEL_EVENTS.hide, this);
+  }
+
+  _cleanupListeners() {
+    super._cleanupListeners();
+    this.panelMultiView.removeEventListener(TABS_PANEL_EVENTS.hide, this);
+  }
+
+  _createRow(tab) {
+    let { doc } = this;
+    let row = doc.createXULElement("toolbaritem");
+    row.setAttribute("class", "all-tabs-item");
+    row.setAttribute("context", "tabContextMenu");
+    if (this.className) {
+      row.classList.add(this.className);
+    }
+    row.tab = tab;
+    row.addEventListener("command", this);
+    this.tabToElement.set(tab, row);
+
+    let button = doc.createXULElement("toolbarbutton");
+    button.setAttribute(
+      "class",
+      "all-tabs-button subviewbutton subviewbutton-iconic"
+    );
+    button.setAttribute("flex", "1");
+    button.setAttribute("crop", "end");
+    button.tab = tab;
+
+    if (tab.userContextId) {
+      tab.classList.forEach(property => {
+        if (property.startsWith("identity-color")) {
+          button.classList.add(property);
+          button.classList.add("all-tabs-container-indicator");
+        }
+      });
+    }
+
+    row.appendChild(button);
+
+    let muteButton = doc.createXULElement("toolbarbutton");
+    muteButton.classList.add(
+      "all-tabs-mute-button",
+      "all-tabs-secondary-button",
+      "subviewbutton"
+    );
+    muteButton.setAttribute("closemenu", "none");
+    muteButton.tab = tab;
+    row.appendChild(muteButton);
+
+    let closeButton = doc.createXULElement("toolbarbutton");
+    closeButton.classList.add(
+      "all-tabs-close-button",
+      "all-tabs-secondary-button",
+      "subviewbutton"
+    );
+    closeButton.setAttribute("closemenu", "none");
+    doc.l10n.setAttributes(closeButton, "tabbrowser-manager-close-tab");
+    closeButton.tab = tab;
+    row.appendChild(closeButton);
+
+    this._setRowAttributes(row, tab);
+
+    return row;
+  }
+
+  _setRowAttributes(row, tab) {
+    setAttributes(row, { selected: tab.selected });
+
+    let tooltiptext = this.gBrowser.getTabTooltip(tab);
+    let busy = tab.getAttribute("busy");
+    let button = row.firstElementChild;
+    setAttributes(button, {
+      busy,
+      label: tab.label,
+      tooltiptext,
+      image: !busy && tab.getAttribute("image"),
+      iconloadingprincipal: tab.getAttribute("iconloadingprincipal"),
+    });
+
+    this._setImageAttributes(row, tab);
+
+    let muteButton = row.querySelector(".all-tabs-mute-button");
+    let muteButtonTooltipString = tab.muted
+      ? "tabbrowser-manager-unmute-tab"
+      : "tabbrowser-manager-mute-tab";
+    this.doc.l10n.setAttributes(muteButton, muteButtonTooltipString);
+
+    setAttributes(muteButton, {
+      muted: tab.muted,
+      soundplaying: tab.soundPlaying,
+      hidden: !(tab.muted || tab.soundPlaying),
+    });
+  }
+
+  _setImageAttributes(row, tab) {
+    let button = row.firstElementChild;
+    let image = button.icon;
+
+    if (image) {
+      let busy = tab.getAttribute("busy");
+      let progress = tab.getAttribute("progress");
+      setAttributes(image, { busy, progress });
+      if (busy) {
+        image.classList.add("tab-throbber-tabslist");
+      } else {
+        image.classList.remove("tab-throbber-tabslist");
+      }
+    }
+  }
+
+  _onDragStart(event) {
+    const row = this._getTargetRowFromEvent(event);
+    if (!row) {
+      return;
+    }
+
+    this.gBrowser.tabContainer.startTabDrag(event, row.firstElementChild.tab, {
+      fromTabList: true,
+    });
+  }
+
+  _getTargetRowFromEvent(event) {
+    return event.target.closest("toolbaritem");
+  }
+
+  _isMovingTabs(event) {
+    var effects = this.gBrowser.tabContainer.getDropEffectForTabDrag(event);
+    return effects == "move";
+  }
+
+  _onDragOver(event) {
+    if (!this._isMovingTabs(event)) {
+      return;
+    }
+
+    if (!this._updateDropTarget(event)) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+  }
+
+  _getRowIndex(row) {
+    return Array.prototype.indexOf.call(this.containerNode.children, row);
+  }
+
+  _onDrop(event) {
+    if (!this._isMovingTabs(event)) {
+      return;
+    }
+
+    if (!this._updateDropTarget(event)) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+
+    let draggedTab = event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0);
+
+    if (draggedTab === this.dropTargetRow.firstElementChild.tab) {
+      this._clearDropTarget();
+      return;
+    }
+
+    const targetTab = this.dropTargetRow.firstElementChild.tab;
+
+    // NOTE: Given the list is opened only when the window is focused,
+    //       we don't have to check `draggedTab.container`.
+
+    let pos;
+    if (draggedTab._tPos < targetTab._tPos) {
+      pos = targetTab._tPos + this.dropTargetDirection;
+    } else {
+      pos = targetTab._tPos + this.dropTargetDirection + 1;
+    }
+    this.gBrowser.moveTabTo(draggedTab, pos);
+
+    this._clearDropTarget();
+  }
+
+  _onDragLeave(event) {
+    if (!this._isMovingTabs(event)) {
+      return;
+    }
+
+    let target = event.relatedTarget;
+    while (target && target != this.containerNode) {
+      target = target.parentNode;
+    }
+    if (target) {
+      return;
+    }
+
+    this._clearDropTarget();
+  }
+
+  _onDragEnd(event) {
+    if (!this._isMovingTabs(event)) {
+      return;
+    }
+
+    this._clearDropTarget();
+  }
+
+  _updateDropTarget(event) {
+    const row = this._getTargetRowFromEvent(event);
+    if (!row) {
+      return false;
+    }
+
+    const rect = row.getBoundingClientRect();
+    const index = this._getRowIndex(row);
+    if (index === -1) {
+      return false;
+    }
+
+    const threshold = rect.height * 0.5;
+    if (event.clientY < rect.top + threshold) {
+      this._setDropTarget(row, -1);
+    } else {
+      this._setDropTarget(row, 0);
+    }
+
+    return true;
+  }
+
+  _setDropTarget(row, direction) {
+    this.dropTargetRow = row;
+    this.dropTargetDirection = direction;
+
+    const holder = this.dropIndicator.parentNode;
+    const holderOffset = holder.getBoundingClientRect().top;
+
+    // Set top to before/after the target row.
+    let top;
+    if (this.dropTargetDirection === -1) {
+      if (this.dropTargetRow.previousSibling) {
+        const rect = this.dropTargetRow.previousSibling.getBoundingClientRect();
+        top = rect.top + rect.height;
+      } else {
+        const rect = this.dropTargetRow.getBoundingClientRect();
+        top = rect.top;
+      }
+    } else {
+      const rect = this.dropTargetRow.getBoundingClientRect();
+      top = rect.top + rect.height;
+    }
+
+    // Avoid overflowing the sub view body.
+    const indicatorHeight = 12;
+    const subViewBody = holder.parentNode;
+    const subViewBodyRect = subViewBody.getBoundingClientRect();
+    top = Math.min(top, subViewBodyRect.bottom - indicatorHeight);
+
+    this.dropIndicator.style.top = `${top - holderOffset - 12}px`;
+    this.dropIndicator.collapsed = false;
+  }
+
+  _clearDropTarget() {
+    if (this.dropTargetRow) {
+      this.dropTargetRow = null;
+    }
+
+    if (this.dropIndicator) {
+      this.dropIndicator.style.top = `0px`;
+      this.dropIndicator.collapsed = true;
+    }
+  }
+
+  _onClick(event) {
+    if (event.button == 1) {
+      const row = this._getTargetRowFromEvent(event);
+      if (!row) {
+        return;
+      }
+
+      this.gBrowser.removeTab(row.tab, {
+        animate: true,
+      });
+    }
+  }
+}
diff --git a/browser/modules/TransientPrefs.sys.mjs b/browser/modules/TransientPrefs.sys.mjs
new file mode 100644
index 0000000000..b9a66ca5cd
--- /dev/null
+++ b/browser/modules/TransientPrefs.sys.mjs
@@ -0,0 +1,19 @@
+/* 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/. */
+
+var prefVisibility = new Map();
+
+/* Use for preferences that should only be visible when they've been modified.
+   When reset to their default state, they remain visible until restarting the
+   application. */
+
+export var TransientPrefs = {
+  prefShouldBeVisible(prefName) {
+    if (Services.prefs.prefHasUserValue(prefName)) {
+      prefVisibility.set(prefName, true);
+    }
+
+    return !!prefVisibility.get(prefName);
+  },
+};
diff --git a/browser/modules/URILoadingHelper.sys.mjs b/browser/modules/URILoadingHelper.sys.mjs
new file mode 100644
index 0000000000..413a28af36
--- /dev/null
+++ b/browser/modules/URILoadingHelper.sys.mjs
@@ -0,0 +1,793 @@
+/* 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/. */
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+import { BrowserUtils } from "resource://gre/modules/BrowserUtils.sys.mjs";
+import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
+  BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
+});
+
+ChromeUtils.defineLazyGetter(lazy, "ReferrerInfo", () =>
+  Components.Constructor(
+    "@mozilla.org/referrer-info;1",
+    "nsIReferrerInfo",
+    "init"
+  )
+);
+
+function saveLink(window, url, params) {
+  if ("isContentWindowPrivate" in params) {
+    window.saveURL(
+      url,
+      null,
+      null,
+      null,
+      true,
+      true,
+      params.referrerInfo,
+      null,
+      null,
+      params.isContentWindowPrivate,
+      params.originPrincipal
+    );
+  } else {
+    if (!params.initiatingDoc) {
+      console.error(
+        "openUILink/openLinkIn was called with " +
+          "where == 'save' but without initiatingDoc.  See bug 814264."
+      );
+      return;
+    }
+    window.saveURL(
+      url,
+      null,
+      null,
+      null,
+      true,
+      true,
+      params.referrerInfo,
+      null,
+      params.initiatingDoc
+    );
+  }
+}
+
+function openInWindow(url, params, sourceWindow) {
+  let {
+    referrerInfo,
+    forceNonPrivate,
+    triggeringRemoteType,
+    forceAllowDataURI,
+    globalHistoryOptions,
+    allowThirdPartyFixup,
+    userContextId,
+    postData,
+    originPrincipal,
+    originStoragePrincipal,
+    triggeringPrincipal,
+    csp,
+    resolveOnContentBrowserCreated,
+  } = params;
+  let features = "chrome,dialog=no,all";
+  if (params.private) {
+    features += ",private";
+    // To prevent regular browsing data from leaking to private browsing sites,
+    // strip the referrer when opening a new private window. (See Bug: 1409226)
+    referrerInfo = new lazy.ReferrerInfo(
+      referrerInfo.referrerPolicy,
+      false,
+      referrerInfo.originalReferrer
+    );
+  } else if (forceNonPrivate) {
+    features += ",non-private";
+  }
+
+  // This propagates to window.arguments.
+  var sa = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+
+  var wuri = Cc["@mozilla.org/supports-string;1"].createInstance(
+    Ci.nsISupportsString
+  );
+  wuri.data = url;
+
+  let extraOptions = Cc["@mozilla.org/hash-property-bag;1"].createInstance(
+    Ci.nsIWritablePropertyBag2
+  );
+  if (triggeringRemoteType) {
+    extraOptions.setPropertyAsACString(
+      "triggeringRemoteType",
+      triggeringRemoteType
+    );
+  }
+  if (params.hasValidUserGestureActivation !== undefined) {
+    extraOptions.setPropertyAsBool(
+      "hasValidUserGestureActivation",
+      params.hasValidUserGestureActivation
+    );
+  }
+  if (forceAllowDataURI) {
+    extraOptions.setPropertyAsBool("forceAllowDataURI", true);
+  }
+  if (params.fromExternal !== undefined) {
+    extraOptions.setPropertyAsBool("fromExternal", params.fromExternal);
+  }
+  if (globalHistoryOptions?.triggeringSponsoredURL) {
+    extraOptions.setPropertyAsACString(
+      "triggeringSponsoredURL",
+      globalHistoryOptions.triggeringSponsoredURL
+    );
+    if (globalHistoryOptions.triggeringSponsoredURLVisitTimeMS) {
+      extraOptions.setPropertyAsUint64(
+        "triggeringSponsoredURLVisitTimeMS",
+        globalHistoryOptions.triggeringSponsoredURLVisitTimeMS
+      );
+    }
+  }
+  if (params.wasSchemelessInput !== undefined) {
+    extraOptions.setPropertyAsBool(
+      "wasSchemelessInput",
+      params.wasSchemelessInput
+    );
+  }
+
+  var allowThirdPartyFixupSupports = Cc[
+    "@mozilla.org/supports-PRBool;1"
+  ].createInstance(Ci.nsISupportsPRBool);
+  allowThirdPartyFixupSupports.data = allowThirdPartyFixup;
+
+  var userContextIdSupports = Cc[
+    "@mozilla.org/supports-PRUint32;1"
+  ].createInstance(Ci.nsISupportsPRUint32);
+  userContextIdSupports.data = userContextId;
+
+  sa.appendElement(wuri);
+  sa.appendElement(extraOptions);
+  sa.appendElement(referrerInfo);
+  sa.appendElement(postData);
+  sa.appendElement(allowThirdPartyFixupSupports);
+  sa.appendElement(userContextIdSupports);
+  sa.appendElement(originPrincipal);
+  sa.appendElement(originStoragePrincipal);
+  sa.appendElement(triggeringPrincipal);
+  sa.appendElement(null); // allowInheritPrincipal
+  sa.appendElement(csp);
+
+  let win;
+
+  // Returns a promise that will be resolved when the new window's startup is finished.
+  function waitForWindowStartup() {
+    return new Promise(resolve => {
+      const delayedStartupObserver = aSubject => {
+        if (aSubject == win) {
+          Services.obs.removeObserver(
+            delayedStartupObserver,
+            "browser-delayed-startup-finished"
+          );
+          resolve();
+        }
+      };
+      Services.obs.addObserver(
+        delayedStartupObserver,
+        "browser-delayed-startup-finished"
+      );
+    });
+  }
+
+  if (params.frameID != undefined && sourceWindow) {
+    // Only notify it as a WebExtensions' webNavigation.onCreatedNavigationTarget
+    // event if it contains the expected frameID params.
+    // (e.g. we should not notify it as a onCreatedNavigationTarget if the user is
+    // opening a new window using the keyboard shortcut).
+    const sourceTabBrowser = sourceWindow.gBrowser.selectedBrowser;
+    waitForWindowStartup().then(() => {
+      Services.obs.notifyObservers(
+        {
+          wrappedJSObject: {
+            url,
+            createdTabBrowser: win.gBrowser.selectedBrowser,
+            sourceTabBrowser,
+            sourceFrameID: params.frameID,
+          },
+        },
+        "webNavigation-createdNavigationTarget"
+      );
+    });
+  }
+
+  if (resolveOnContentBrowserCreated) {
+    waitForWindowStartup().then(() =>
+      resolveOnContentBrowserCreated(win.gBrowser.selectedBrowser)
+    );
+  }
+
+  win = Services.ww.openWindow(
+    sourceWindow,
+    AppConstants.BROWSER_CHROME_URL,
+    null,
+    features,
+    sa
+  );
+}
+
+function openInCurrentTab(targetBrowser, url, uriObj, params) {
+  let flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
+
+  if (params.allowThirdPartyFixup) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
+  }
+  // LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL isn't supported for javascript URIs,
+  // i.e. it causes them not to load at all. Callers should strip
+  // "javascript:" from pasted strings to prevent blank tabs
+  if (!params.allowInheritPrincipal) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL;
+  }
+
+  if (params.allowPopups) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_POPUPS;
+  }
+  if (params.indicateErrorPageLoad) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_ERROR_LOAD_CHANGES_RV;
+  }
+  if (params.forceAllowDataURI) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FORCE_ALLOW_DATA_URI;
+  }
+  if (params.fromExternal) {
+    flags |= Ci.nsIWebNavigation.LOAD_FLAGS_FROM_EXTERNAL;
+  }
+
+  let { URI_INHERITS_SECURITY_CONTEXT } = Ci.nsIProtocolHandler;
+  if (
+    params.forceAboutBlankViewerInCurrent &&
+    (!uriObj ||
+      Services.io.getDynamicProtocolFlags(uriObj) &
+        URI_INHERITS_SECURITY_CONTEXT)
+  ) {
+    // Unless we know for sure we're not inheriting principals,
+    // force the about:blank viewer to have the right principal:
+    targetBrowser.createAboutBlankDocumentViewer(
+      params.originPrincipal,
+      params.originStoragePrincipal
+    );
+  }
+
+  let {
+    triggeringPrincipal,
+    csp,
+    referrerInfo,
+    postData,
+    userContextId,
+    hasValidUserGestureActivation,
+    globalHistoryOptions,
+    triggeringRemoteType,
+    wasSchemelessInput,
+  } = params;
+
+  targetBrowser.fixupAndLoadURIString(url, {
+    triggeringPrincipal,
+    csp,
+    flags,
+    referrerInfo,
+    postData,
+    userContextId,
+    hasValidUserGestureActivation,
+    globalHistoryOptions,
+    triggeringRemoteType,
+    wasSchemelessInput,
+  });
+  params.resolveOnContentBrowserCreated?.(targetBrowser);
+}
+
+function updatePrincipals(window, params) {
+  let { userContextId } = params;
+  // Teach the principal about the right OA to use, e.g. in case when
+  // opening a link in a new private window, or in a new container tab.
+  // Please note we do not have to do that for SystemPrincipals and we
+  // can not do it for NullPrincipals since NullPrincipals are only
+  // identical if they actually are the same object (See Bug: 1346759)
+  function useOAForPrincipal(principal) {
+    if (principal && principal.isContentPrincipal) {
+      let privateBrowsingId =
+        params.private ||
+        (window && PrivateBrowsingUtils.isWindowPrivate(window));
+      let attrs = {
+        userContextId,
+        privateBrowsingId,
+        firstPartyDomain: principal.originAttributes.firstPartyDomain,
+      };
+      return Services.scriptSecurityManager.principalWithOA(principal, attrs);
+    }
+    return principal;
+  }
+  params.originPrincipal = useOAForPrincipal(params.originPrincipal);
+  params.originStoragePrincipal = useOAForPrincipal(
+    params.originStoragePrincipal
+  );
+  params.triggeringPrincipal = useOAForPrincipal(params.triggeringPrincipal);
+}
+
+export const URILoadingHelper = {
+  /* openLinkIn opens a URL in a place specified by the parameter |where|.
+   *
+   * The params object is the same as for `openLinkIn` and documented below.
+   *
+   * @param {String}  where
+   *   |where| can be:
+   *    "current"     current tab            (if there aren't any browser windows, then in a new window instead)
+   *    "tab"         new tab                (if there aren't any browser windows, then in a new window instead)
+   *    "tabshifted"  same as "tab" but in background if default is to select new tabs, and vice versa
+   *    "window"      new window
+   *    "save"        save to disk (with no filename hint!)
+   *
+   * @param {Object}  params
+   *
+   * Options relating to what tab/window to use and how to open it:
+   *
+   * @param {boolean} params.private
+   *                  Load the URL in a private window.
+   * @param {boolean} params.forceNonPrivate
+   *                  Force the load to happen in non-private windows.
+   * @param {boolean} params.relatedToCurrent
+   *                  Whether new tabs should go immediately next to the current tab.
+   * @param {Element} params.targetBrowser
+   *                  The browser to use for the load. Only used if where == "current".
+   * @param {boolean} params.inBackground
+   *                  If explicitly true or false, whether to switch to the tab immediately.
+   *                  If null, will switch to the tab if `forceForeground` was true. If
+   *                  neither is passed, will defer to the user preference browser.tabs.loadInBackground.
+   * @param {boolean} params.forceForeground
+   *                  Ignore the user preference and load in the foreground.
+   * @param {boolean} params.allowPinnedTabHostChange
+   *                  Allow even a pinned tab to change hosts.
+   * @param {boolean} params.allowPopups
+   *                  whether the link is allowed to open in a popup window (ie one with no browser
+   *                  chrome)
+   * @param {boolean} params.skipTabAnimation
+   *                  Skip the tab opening animation.
+   * @param {Element} params.openerBrowser
+   *                  The browser that started the load.
+   * @param {boolean} params.avoidBrowserFocus
+   *                  Don't focus the browser element immediately after starting
+   *                  the load. Used by the URL bar to avoid leaking user input
+   *                  into web content, see bug 1641287.
+   *
+   * Options relating to the load itself:
+   *
+   * @param {boolean} params.allowThirdPartyFixup
+   *                  Allow transforming the 'url' into a search query.
+   * @param {nsIInputStream} params.postData
+   *                  Data to post as part of the request.
+   * @param {nsIReferrerInfo} params.referrerInfo
+   *                  Referrer info for the request.
+   * @param {boolean} params.indicateErrorPageLoad
+   *                  Whether docshell should throw an exception (i.e. return non-NS_OK)
+   *                  if the load fails.
+   * @param {string}  params.charset
+   *                  Character set to use for the load. Only honoured for tabs.
+   *                  Legacy argument - do not use.
+   * @param {string}  params.wasSchemelessInput
+   *                  Whether the search/URL term was without an explicit scheme.
+   *
+   * Options relating to security, whether the load is allowed to happen,
+   * and what cookie container to use for the load:
+   *
+   * @param {boolean} params.forceAllowDataURI
+   *                  Force allow a data URI to load as a toplevel load.
+   * @param {number}  params.userContextId
+   *                  The userContextId (container identifier) to use for the load.
+   * @param {boolean} params.allowInheritPrincipal
+   *                  Allow the load to inherit the triggering principal.
+   * @param {boolean} params.forceAboutBlankViewerInCurrent
+   *                  Force load an about:blank page first. Only used if
+   *                  allowInheritPrincipal is passed or no URL was provided.
+   * @param {nsIPrincipal} params.triggeringPrincipal
+   *                  Triggering principal to pass to docshell for the load.
+   * @param {nsIPrincipal} params.originPrincipal
+   *                  Origin principal to pass to docshell for the load.
+   * @param {nsIPrincipal} params.originStoragePrincipal
+   *                  Storage principal to pass to docshell for the load.
+   * @param {string}  params.triggeringRemoteType
+   *                  The remoteType triggering this load.
+   * @param {nsIContentSecurityPolicy} params.csp
+   *                  The CSP that should apply to the load.
+   * @param {boolean} params.hasValidUserGestureActivation
+   *                  Indicates if a valid user gesture caused this load. This
+   *                  informs e.g. popup blocker decisions.
+   * @param {boolean} params.fromExternal
+   *                  Indicates the load was started outside of the browser,
+   *                  e.g. passed on the commandline or through OS mechanisms.
+   *
+   * Options used to track the load elsewhere
+   *
+   * @param {function} params.resolveOnNewTabCreated
+   *                   This callback will be called when a new tab is created.
+   * @param {function} params.resolveOnContentBrowserCreated
+   *                   This callback will be called with the content browser once it's created.
+   * @param {Object}   params.globalHistoryOptions
+   *                   Used by places to keep track of search related metadata for loads.
+   * @param {Number}   params.frameID
+   *                   Used by webextensions for their loads.
+   *
+   * Options used for where="save" only:
+   *
+   * @param {boolean}  params.isContentWindowPrivate
+   *                   Save content as coming from a private window.
+   * @param {Document} params.initiatingDoc
+   *                   Used to determine where to prompt for a filename.
+   */
+  openLinkIn(window, url, where, params) {
+    if (!where || !url) {
+      return;
+    }
+
+    let {
+      allowThirdPartyFixup,
+      postData,
+      charset,
+      relatedToCurrent,
+      allowInheritPrincipal,
+      forceAllowDataURI,
+      forceNonPrivate,
+      skipTabAnimation,
+      allowPinnedTabHostChange,
+      userContextId,
+      triggeringPrincipal,
+      originPrincipal,
+      originStoragePrincipal,
+      triggeringRemoteType,
+      csp,
+      resolveOnNewTabCreated,
+      resolveOnContentBrowserCreated,
+      globalHistoryOptions,
+    } = params;
+
+    // We want to overwrite some things for convenience when passing it to other
+    // methods. To avoid impacting callers, copy the params.
+    params = Object.assign({}, params);
+
+    if (!params.referrerInfo) {
+      params.referrerInfo = new lazy.ReferrerInfo(
+        Ci.nsIReferrerInfo.EMPTY,
+        true,
+        null
+      );
+    }
+
+    if (!triggeringPrincipal) {
+      throw new Error("Must load with a triggering Principal");
+    }
+
+    if (where == "save") {
+      saveLink(window, url, params);
+      return;
+    }
+
+    // Establish which window we'll load the link in.
+    let w;
+    if (where == "current" && params.targetBrowser) {
+      w = params.targetBrowser.ownerGlobal;
+    } else {
+      w = this.getTargetWindow(window, { forceNonPrivate });
+    }
+    // We don't want to open tabs in popups, so try to find a non-popup window in
+    // that case.
+    if ((where == "tab" || where == "tabshifted") && w && !w.toolbar.visible) {
+      w = this.getTargetWindow(window, {
+        skipPopups: true,
+        forceNonPrivate,
+      });
+      relatedToCurrent = false;
+    }
+
+    updatePrincipals(w, params);
+
+    if (!w || where == "window") {
+      openInWindow(url, params, w || window);
+      return;
+    }
+
+    // We're now committed to loading the link in an existing browser window.
+
+    // Raise the target window before loading the URI, since loading it may
+    // result in a new frontmost window (e.g. "javascript:window.open('');").
+    w.focus();
+
+    let targetBrowser;
+    let loadInBackground;
+    let uriObj;
+
+    if (where == "current") {
+      targetBrowser = params.targetBrowser || w.gBrowser.selectedBrowser;
+      loadInBackground = false;
+      try {
+        uriObj = Services.io.newURI(url);
+      } catch (e) {}
+
+      // In certain tabs, we restrict what if anything may replace the loaded
+      // page. If a load request bounces off for the currently selected tab,
+      // we'll open a new tab instead.
+      let tab = w.gBrowser.getTabForBrowser(targetBrowser);
+      if (tab == w.FirefoxViewHandler.tab) {
+        where = "tab";
+        targetBrowser = null;
+      } else if (
+        !allowPinnedTabHostChange &&
+        tab.pinned &&
+        url != "about:crashcontent"
+      ) {
+        try {
+          // nsIURI.host can throw for non-nsStandardURL nsIURIs.
+          if (
+            !uriObj ||
+            (!uriObj.schemeIs("javascript") &&
+              targetBrowser.currentURI.host != uriObj.host)
+          ) {
+            where = "tab";
+            targetBrowser = null;
+          }
+        } catch (err) {
+          where = "tab";
+          targetBrowser = null;
+        }
+      }
+    } else {
+      // `where` is "tab" or "tabshifted", so we'll load the link in a new tab.
+      loadInBackground = params.inBackground;
+      if (loadInBackground == null) {
+        loadInBackground = params.forceForeground
+          ? false
+          : Services.prefs.getBoolPref("browser.tabs.loadInBackground");
+      }
+    }
+
+    let focusUrlBar = false;
+
+    switch (where) {
+      case "current":
+        openInCurrentTab(targetBrowser, url, uriObj, params);
+
+        // Don't focus the content area if focus is in the address bar and we're
+        // loading the New Tab page.
+        focusUrlBar =
+          w.document.activeElement == w.gURLBar.inputField &&
+          w.isBlankPageURL(url);
+        break;
+      case "tabshifted":
+        loadInBackground = !loadInBackground;
+      // fall through
+      case "tab":
+        focusUrlBar =
+          !loadInBackground &&
+          w.isBlankPageURL(url) &&
+          !lazy.AboutNewTab.willNotifyUser;
+
+        let tabUsedForLoad = w.gBrowser.addTab(url, {
+          referrerInfo: params.referrerInfo,
+          charset,
+          postData,
+          inBackground: loadInBackground,
+          allowThirdPartyFixup,
+          relatedToCurrent,
+          skipAnimation: skipTabAnimation,
+          userContextId,
+          originPrincipal,
+          originStoragePrincipal,
+          triggeringPrincipal,
+          allowInheritPrincipal,
+          triggeringRemoteType,
+          csp,
+          forceAllowDataURI,
+          focusUrlBar,
+          openerBrowser: params.openerBrowser,
+          fromExternal: params.fromExternal,
+          globalHistoryOptions,
+          wasSchemelessInput: params.wasSchemelessInput,
+        });
+        targetBrowser = tabUsedForLoad.linkedBrowser;
+
+        resolveOnNewTabCreated?.(targetBrowser);
+        resolveOnContentBrowserCreated?.(targetBrowser);
+
+        if (params.frameID != undefined && w) {
+          // Only notify it as a WebExtensions' webNavigation.onCreatedNavigationTarget
+          // event if it contains the expected frameID params.
+          // (e.g. we should not notify it as a onCreatedNavigationTarget if the user is
+          // opening a new tab using the keyboard shortcut).
+          Services.obs.notifyObservers(
+            {
+              wrappedJSObject: {
+                url,
+                createdTabBrowser: targetBrowser,
+                sourceTabBrowser: w.gBrowser.selectedBrowser,
+                sourceFrameID: params.frameID,
+              },
+            },
+            "webNavigation-createdNavigationTarget"
+          );
+        }
+        break;
+    }
+
+    if (
+      !params.avoidBrowserFocus &&
+      !focusUrlBar &&
+      targetBrowser == w.gBrowser.selectedBrowser
+    ) {
+      // Focus the content, but only if the browser used for the load is selected.
+      targetBrowser.focus();
+    }
+  },
+
+  /**
+   * Finds a browser window suitable for opening a link matching the
+   * requirements given in the `params` argument. If the current window matches
+   * the requirements then it is returned otherwise the top-most window that
+   * matches will be returned.
+   *
+   * @param {Window} window - The current window.
+   * @param {Object} params - Parameters for selecting the window.
+   * @param {boolean} params.skipPopups - Require a non-popup window.
+   * @param {boolean} params.forceNonPrivate - Require a non-private window.
+   * @returns {Window | null} A matching browser window or null if none matched.
+   */
+  getTargetWindow(window, { skipPopups, forceNonPrivate } = {}) {
+    let { top } = window;
+    // If this is called in a browser window, use that window regardless of
+    // whether it's the frontmost window, since commands can be executed in
+    // background windows (bug 626148).
+    if (
+      top.document.documentElement.getAttribute("windowtype") ==
+        "navigator:browser" &&
+      (!skipPopups || top.toolbar.visible) &&
+      (!forceNonPrivate || !PrivateBrowsingUtils.isWindowPrivate(top))
+    ) {
+      return top;
+    }
+
+    return lazy.BrowserWindowTracker.getTopWindow({
+      private: !forceNonPrivate && PrivateBrowsingUtils.isWindowPrivate(window),
+      allowPopups: !skipPopups,
+    });
+  },
+
+  /**
+   * openUILink handles clicks on UI elements that cause URLs to load.
+   *
+   * @param {string} url
+   * @param {Event | Object} event Event or JSON object representing an Event
+   * @param {Boolean | Object} aIgnoreButton
+   *                           Boolean or object with the same properties as
+   *                           accepted by openLinkIn, plus "ignoreButton"
+   *                           and "ignoreAlt".
+   * @param {Boolean} aIgnoreAlt
+   * @param {Boolean} aAllowThirdPartyFixup
+   * @param {Object} aPostData
+   * @param {Object} aReferrerInfo
+   */
+  openUILink(
+    window,
+    url,
+    event,
+    aIgnoreButton,
+    aIgnoreAlt,
+    aAllowThirdPartyFixup,
+    aPostData,
+    aReferrerInfo
+  ) {
+    event = BrowserUtils.getRootEvent(event);
+    let params;
+
+    if (aIgnoreButton && typeof aIgnoreButton == "object") {
+      params = aIgnoreButton;
+
+      // don't forward "ignoreButton" and "ignoreAlt" to openLinkIn
+      aIgnoreButton = params.ignoreButton;
+      aIgnoreAlt = params.ignoreAlt;
+      delete params.ignoreButton;
+      delete params.ignoreAlt;
+    } else {
+      params = {
+        allowThirdPartyFixup: aAllowThirdPartyFixup,
+        postData: aPostData,
+        referrerInfo: aReferrerInfo,
+        initiatingDoc: event ? event.target.ownerDocument : null,
+      };
+    }
+
+    if (!params.triggeringPrincipal) {
+      throw new Error(
+        "Required argument triggeringPrincipal missing within openUILink"
+      );
+    }
+
+    let where = BrowserUtils.whereToOpenLink(event, aIgnoreButton, aIgnoreAlt);
+    params.forceForeground ??= true;
+    this.openLinkIn(window, url, where, params);
+  },
+
+  /* openTrustedLinkIn will attempt to open the given URI using the SystemPrincipal
+   * as the trigeringPrincipal, unless a more specific Principal is provided.
+   *
+   * Otherwise, parameters are the same as openLinkIn, but we will set `forceForeground`
+   * to true.
+   */
+  openTrustedLinkIn(window, url, where, params = {}) {
+    if (!params.triggeringPrincipal) {
+      params.triggeringPrincipal =
+        Services.scriptSecurityManager.getSystemPrincipal();
+    }
+
+    params.forceForeground ??= true;
+    this.openLinkIn(window, url, where, params);
+  },
+
+  /* openWebLinkIn will attempt to open the given URI using the NullPrincipal
+   * as the triggeringPrincipal, unless a more specific Principal is provided.
+   *
+   * Otherwise, parameters are the same as openLinkIn, but we will set `forceForeground`
+   * to true.
+   */
+  openWebLinkIn(window, url, where, params = {}) {
+    if (!params.triggeringPrincipal) {
+      params.triggeringPrincipal =
+        Services.scriptSecurityManager.createNullPrincipal({});
+    }
+    if (params.triggeringPrincipal.isSystemPrincipal) {
+      throw new Error(
+        "System principal should never be passed into openWebLinkIn()"
+      );
+    }
+    params.forceForeground ??= true;
+    this.openLinkIn(window, url, where, params);
+  },
+
+  /**
+   * Given a URI, guess which container to use to open it. This is used for external
+   * openers as a quality of life improvement (e.g. to open a document into the container
+   * where you are logged in to the service that hosts it).
+   * matches will be returned.
+   * For now this can only use currently-open tabs, until history is tagged with the
+   * container id (https://bugzilla.mozilla.org/show_bug.cgi?id=1283320).
+   *
+   * @param {nsIURI} aURI - The URI being opened.
+   * @returns {number | null} The guessed userContextId, or null if none.
+   */
+  guessUserContextId(aURI) {
+    let host;
+    try {
+      host = aURI.host;
+    } catch (e) {}
+    if (!host) {
+      return null;
+    }
+    const containerScores = new Map();
+    let guessedUserContextId = null;
+    let maxCount = 0;
+    for (let win of lazy.BrowserWindowTracker.orderedWindows) {
+      for (let tab of win.gBrowser.visibleTabs) {
+        let { userContextId } = tab;
+        let currentURIHost = null;
+        try {
+          currentURIHost = tab.linkedBrowser.currentURI.host;
+        } catch (e) {}
+
+        if (currentURIHost == host) {
+          let count = (containerScores.get(userContextId) ?? 0) + 1;
+          containerScores.set(userContextId, count);
+          if (count > maxCount) {
+            guessedUserContextId = userContextId;
+            maxCount = count;
+          }
+        }
+      }
+    }
+
+    return guessedUserContextId;
+  },
+};
diff --git a/browser/modules/WindowsJumpLists.sys.mjs b/browser/modules/WindowsJumpLists.sys.mjs
new file mode 100644
index 0000000000..9015527423
--- /dev/null
+++ b/browser/modules/WindowsJumpLists.sys.mjs
@@ -0,0 +1,859 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+// Stop updating jumplists after some idle time.
+const IDLE_TIMEOUT_SECONDS = 5 * 60;
+
+// Prefs
+const PREF_TASKBAR_BRANCH = "browser.taskbar.lists.";
+const PREF_TASKBAR_LEGACY_BACKEND = "legacyBackend";
+const PREF_TASKBAR_ENABLED = "enabled";
+const PREF_TASKBAR_ITEMCOUNT = "maxListItemCount";
+const PREF_TASKBAR_FREQUENT = "frequent.enabled";
+const PREF_TASKBAR_RECENT = "recent.enabled";
+const PREF_TASKBAR_TASKS = "tasks.enabled";
+const PREF_TASKBAR_REFRESH = "refreshInSeconds";
+
+// Hash keys for pendingStatements.
+const LIST_TYPE = {
+  FREQUENT: 0,
+  RECENT: 1,
+};
+
+/**
+ * Exports
+ */
+
+const lazy = {};
+
+/**
+ * Smart getters
+ */
+
+ChromeUtils.defineLazyGetter(lazy, "_prefs", function () {
+  return Services.prefs.getBranch(PREF_TASKBAR_BRANCH);
+});
+
+ChromeUtils.defineLazyGetter(lazy, "_stringBundle", function () {
+  return Services.strings.createBundle(
+    "chrome://browser/locale/taskbar.properties"
+  );
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "_idle",
+  "@mozilla.org/widget/useridleservice;1",
+  "nsIUserIdleService"
+);
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "_taskbarService",
+  "@mozilla.org/windows-taskbar;1",
+  "nsIWinTaskbar"
+);
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+/**
+ * Global functions
+ */
+
+function _getString(name) {
+  return lazy._stringBundle.GetStringFromName(name);
+}
+
+// Task list configuration data object.
+
+var tasksCfg = [
+  /**
+   * Task configuration options: title, description, args, iconIndex, open, close.
+   *
+   * title       - Task title displayed in the list. (strings in the table are temp fillers.)
+   * description - Tooltip description on the list item.
+   * args        - Command line args to invoke the task.
+   * iconIndex   - Optional win icon index into the main application for the
+   *               list item.
+   * open        - Boolean indicates if the command should be visible after the browser opens.
+   * close       - Boolean indicates if the command should be visible after the browser closes.
+   */
+  // Open new tab
+  {
+    get title() {
+      return _getString("taskbar.tasks.newTab.label");
+    },
+    get description() {
+      return _getString("taskbar.tasks.newTab.description");
+    },
+    args: "-new-tab about:blank",
+    iconIndex: 3, // New window icon
+    open: true,
+    close: true, // The jump list already has an app launch icon, but
+    // we don't always update the list on shutdown.
+    // Thus true for consistency.
+  },
+
+  // Open new window
+  {
+    get title() {
+      return _getString("taskbar.tasks.newWindow.label");
+    },
+    get description() {
+      return _getString("taskbar.tasks.newWindow.description");
+    },
+    args: "-browser",
+    iconIndex: 2, // New tab icon
+    open: true,
+    close: true, // No point, but we don't always update the list on
+    // shutdown. Thus true for consistency.
+  },
+];
+
+// Open new private window
+let privateWindowTask = {
+  get title() {
+    return _getString("taskbar.tasks.newPrivateWindow.label");
+  },
+  get description() {
+    return _getString("taskbar.tasks.newPrivateWindow.description");
+  },
+  args: "-private-window",
+  iconIndex: 4, // Private browsing mode icon
+  open: true,
+  close: true, // No point, but we don't always update the list on
+  // shutdown. Thus true for consistency.
+};
+
+// Implementation
+
+var Builder = class {
+  constructor(builder) {
+    this._builder = builder;
+    this._tasks = null;
+    this._pendingStatements = {};
+    this._shuttingDown = false;
+    // These are ultimately controlled by prefs, so we disable
+    // everything until is read from there
+    this._showTasks = false;
+    this._showFrequent = false;
+    this._showRecent = false;
+    this._maxItemCount = 0;
+    this._isBuilding = false;
+  }
+
+  refreshPrefs(showTasks, showFrequent, showRecent, maxItemCount) {
+    this._showTasks = showTasks;
+    this._showFrequent = showFrequent;
+    this._showRecent = showRecent;
+    this._maxItemCount = maxItemCount;
+  }
+
+  updateShutdownState(shuttingDown) {
+    this._shuttingDown = shuttingDown;
+  }
+
+  delete() {
+    delete this._builder;
+  }
+
+  /**
+   * Constructs the tasks and recent history items to display in the JumpList,
+   * and then sends those lists to the nsIJumpListBuilder to be written.
+   *
+   * @returns {Promise<undefined>}
+   *   The Promise resolves once the JumpList has been written, and any
+   *   items that the user remove from the recent history list have been
+   *   removed from Places. The Promise may reject if any part of constructing
+   *   the tasks or sending them to the builder thread failed.
+   */
+  async buildList() {
+    if (!(this._builder instanceof Ci.nsIJumpListBuilder)) {
+      console.error(
+        "Expected nsIJumpListBuilder. The builder is of the wrong type."
+      );
+      return;
+    }
+
+    // anything to build?
+    if (!this._showFrequent && !this._showRecent && !this._showTasks) {
+      // don't leave the last list hanging on the taskbar.
+      this._deleteActiveJumpList();
+      return;
+    }
+
+    // Are we in the midst of building an earlier iteration of this list? If
+    // so, bail out. Same if we're shutting down.
+    if (this._isBuilding || this._shuttingDown) {
+      return;
+    }
+
+    this._isBuilding = true;
+
+    try {
+      let removedURLs = await this._builder.checkForRemovals();
+      if (removedURLs.length) {
+        await this._clearHistory(removedURLs);
+      }
+
+      let selfPath = Services.dirsvc.get("XREExeF", Ci.nsIFile).path;
+
+      let taskDescriptions = [];
+
+      if (this._showTasks) {
+        taskDescriptions = this._tasks.map(task => {
+          return {
+            title: task.title,
+            description: task.description,
+            path: selfPath,
+            arguments: task.args,
+            fallbackIconIndex: task.iconIndex,
+          };
+        });
+      }
+
+      let customTitle = "";
+      let customDescriptions = [];
+
+      if (this._showFrequent) {
+        let conn = await lazy.PlacesUtils.promiseDBConnection();
+        let rows = await conn.executeCached(
+          "SELECT p.url, IFNULL(p.title, p.url) as title " +
+            "FROM moz_places p WHERE p.hidden = 0 " +
+            "AND EXISTS (" +
+            "SELECT id FROM moz_historyvisits WHERE " +
+            "place_id = p.id AND " +
+            "visit_type NOT IN (" +
+            "0, " +
+            `${Ci.nsINavHistoryService.TRANSITION_EMBED}, ` +
+            `${Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK}` +
+            ")" +
+            "LIMIT 1" +
+            ") " +
+            "ORDER BY p.visit_count DESC LIMIT :limit",
+          {
+            limit: this._maxItemCount,
+          }
+        );
+
+        customDescriptions = rows.map(row => {
+          let uri = Services.io.newURI(row.getResultByName("url"));
+          let iconPath = "";
+          try {
+            iconPath = this._builder.obtainAndCacheFavicon(uri);
+          } catch (e) {
+            // obtainAndCacheFavicon may throw NS_ERROR_NOT_AVAILABLE if the
+            // icon doesn't yet exist on the disk, but has been requested.
+            // That's not fatal, so we'll just let it pass. Any other errors,
+            // however, we'll abort on.
+            if (e.result != Cr.NS_ERROR_NOT_AVAILABLE) {
+              throw e;
+            }
+          }
+
+          return {
+            title: row.getResultByName("title"),
+            description: row.getResultByName("title"),
+            path: selfPath,
+            arguments: row.getResultByName("url"),
+            fallbackIconIndex: 1,
+            iconPath,
+          };
+        });
+
+        customTitle = _getString("taskbar.frequent.label");
+      }
+
+      if (!this._shuttingDown) {
+        await this._builder.populateJumpList(
+          taskDescriptions,
+          customTitle,
+          customDescriptions
+        );
+      }
+    } catch (e) {
+      console.error("buildList failed: ", e);
+    } finally {
+      this._isBuilding = false;
+    }
+  }
+
+  /**
+   * Legacy list building
+   *
+   * @note Async builders must add their mozIStoragePendingStatement to
+   *       _pendingStatements object, using a different LIST_TYPE entry for
+   *       each statement. Once finished they must remove it and call
+   *       commitBuild().  When there will be no more _pendingStatements,
+   *       commitBuild() will commit for real.
+   */
+
+  _hasPendingStatements() {
+    return !!Object.keys(this._pendingStatements).length;
+  }
+
+  async buildListLegacy() {
+    if (!(this._builder instanceof Ci.nsILegacyJumpListBuilder)) {
+      console.error(
+        "Expected nsILegacyJumpListBuilder. The builder is of the wrong type."
+      );
+      return;
+    }
+
+    if (
+      (this._showFrequent || this._showRecent) &&
+      this._hasPendingStatements()
+    ) {
+      // We were requested to update the list while another update was in
+      // progress, this could happen at shutdown, idle or privatebrowsing.
+      // Abort the current list building.
+      for (let listType in this._pendingStatements) {
+        this._pendingStatements[listType].cancel();
+        delete this._pendingStatements[listType];
+      }
+      this._builder.abortListBuild();
+    }
+
+    // anything to build?
+    if (!this._showFrequent && !this._showRecent && !this._showTasks) {
+      // don't leave the last list hanging on the taskbar.
+      this._deleteActiveJumpList();
+      return;
+    }
+
+    await this._startBuild();
+
+    if (this._showTasks) {
+      this._buildTasks();
+    }
+
+    // Space for frequent items takes priority over recent.
+    if (this._showFrequent) {
+      this._buildFrequent();
+    }
+
+    if (this._showRecent) {
+      this._buildRecent();
+    }
+
+    this._commitBuild();
+  }
+
+  /**
+   * Taskbar api wrappers
+   */
+
+  async _startBuild() {
+    this._builder.abortListBuild();
+    let URIsToRemove = await this._builder.initListBuild();
+    if (URIsToRemove.length) {
+      // Prior to building, delete removed items from history.
+      this._clearHistory(URIsToRemove);
+    }
+  }
+
+  _commitBuild() {
+    if (
+      (this._showFrequent || this._showRecent) &&
+      this._hasPendingStatements()
+    ) {
+      return;
+    }
+
+    this._builder.commitListBuild(succeed => {
+      if (!succeed) {
+        this._builder.abortListBuild();
+      }
+    });
+  }
+
+  _buildTasks() {
+    var items = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+    this._tasks.forEach(function (task) {
+      if (
+        (this._shuttingDown && !task.close) ||
+        (!this._shuttingDown && !task.open)
+      ) {
+        return;
+      }
+      var item = this._getHandlerAppItem(
+        task.title,
+        task.description,
+        task.args,
+        task.iconIndex,
+        null
+      );
+      items.appendElement(item);
+    }, this);
+
+    if (items.length) {
+      this._builder.addListToBuild(
+        this._builder.JUMPLIST_CATEGORY_TASKS,
+        items
+      );
+    }
+  }
+
+  _buildCustom(title, items) {
+    if (items.length) {
+      this._builder.addListToBuild(
+        this._builder.JUMPLIST_CATEGORY_CUSTOMLIST,
+        items,
+        title
+      );
+    }
+  }
+
+  _buildFrequent() {
+    // Windows supports default frequent and recent lists,
+    // but those depend on internal windows visit tracking
+    // which we don't populate. So we build our own custom
+    // frequent and recent lists using our nav history data.
+
+    var items = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+    // track frequent items so that we don't add them to
+    // the recent list.
+    this._frequentHashList = [];
+
+    this._pendingStatements[LIST_TYPE.FREQUENT] = this._getHistoryResults(
+      Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_DESCENDING,
+      this._maxItemCount,
+      function (aResult) {
+        if (!aResult) {
+          delete this._pendingStatements[LIST_TYPE.FREQUENT];
+          // The are no more results, build the list.
+          this._buildCustom(_getString("taskbar.frequent.label"), items);
+          this._commitBuild();
+          return;
+        }
+
+        let title = aResult.title || aResult.uri;
+        let faviconPageUri = Services.io.newURI(aResult.uri);
+        let shortcut = this._getHandlerAppItem(
+          title,
+          title,
+          aResult.uri,
+          1,
+          faviconPageUri
+        );
+        items.appendElement(shortcut);
+        this._frequentHashList.push(aResult.uri);
+      },
+      this
+    );
+  }
+
+  _buildRecent() {
+    var items = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+    // Frequent items will be skipped, so we select a double amount of
+    // entries and stop fetching results at _maxItemCount.
+    var count = 0;
+
+    this._pendingStatements[LIST_TYPE.RECENT] = this._getHistoryResults(
+      Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING,
+      this._maxItemCount * 2,
+      function (aResult) {
+        if (!aResult) {
+          // The are no more results, build the list.
+          this._buildCustom(_getString("taskbar.recent.label"), items);
+          delete this._pendingStatements[LIST_TYPE.RECENT];
+          this._commitBuild();
+          return;
+        }
+
+        if (count >= this._maxItemCount) {
+          return;
+        }
+
+        // Do not add items to recent that have already been added to frequent.
+        if (
+          this._frequentHashList &&
+          this._frequentHashList.includes(aResult.uri)
+        ) {
+          return;
+        }
+
+        let title = aResult.title || aResult.uri;
+        let faviconPageUri = Services.io.newURI(aResult.uri);
+        let shortcut = this._getHandlerAppItem(
+          title,
+          title,
+          aResult.uri,
+          1,
+          faviconPageUri
+        );
+        items.appendElement(shortcut);
+        count++;
+      },
+      this
+    );
+  }
+
+  _deleteActiveJumpList() {
+    if (this._builder instanceof Ci.nsIJumpListBuilder) {
+      this._builder.clearJumpList();
+    } else {
+      this._builder.deleteActiveList();
+    }
+  }
+
+  /**
+   * Jump list item creation helpers
+   */
+
+  _getHandlerAppItem(name, description, args, iconIndex, faviconPageUri) {
+    var file = Services.dirsvc.get("XREExeF", Ci.nsIFile);
+
+    var handlerApp = Cc[
+      "@mozilla.org/uriloader/local-handler-app;1"
+    ].createInstance(Ci.nsILocalHandlerApp);
+    handlerApp.executable = file;
+    // handlers default to the leaf name if a name is not specified
+    if (name && name.length) {
+      handlerApp.name = name;
+    }
+    handlerApp.detailedDescription = description;
+    handlerApp.appendParameter(args);
+
+    var item = Cc[
+      "@mozilla.org/windows-legacyjumplistshortcut;1"
+    ].createInstance(Ci.nsILegacyJumpListShortcut);
+    item.app = handlerApp;
+    item.iconIndex = iconIndex;
+    item.faviconPageUri = faviconPageUri;
+    return item;
+  }
+
+  /**
+   * Nav history helpers
+   */
+
+  _getHistoryResults(aSortingMode, aLimit, aCallback, aScope) {
+    var options = lazy.PlacesUtils.history.getNewQueryOptions();
+    options.maxResults = aLimit;
+    options.sortingMode = aSortingMode;
+    var query = lazy.PlacesUtils.history.getNewQuery();
+
+    // Return the pending statement to the caller, to allow cancelation.
+    return lazy.PlacesUtils.history.asyncExecuteLegacyQuery(query, options, {
+      handleResult(aResultSet) {
+        for (let row; (row = aResultSet.getNextRow()); ) {
+          try {
+            aCallback.call(aScope, {
+              uri: row.getResultByIndex(1),
+              title: row.getResultByIndex(2),
+            });
+          } catch (e) {}
+        }
+      },
+      handleError(aError) {
+        console.error(
+          "Async execution error (",
+          aError.result,
+          "): ",
+          aError.message
+        );
+      },
+      handleCompletion(aReason) {
+        aCallback.call(aScope, null);
+      },
+    });
+  }
+
+  /**
+   * Removes URLs from history in Places that the user has requested to clear
+   * from their Jump List. We must do this before recomputing which history
+   * to put into the Jump List, because if we ever include items that have
+   * recently been removed, Windows will not allow us to proceed.
+   * Please see
+   * https://learn.microsoft.com/en-us/windows/win32/api/shobjidl_core/nf-shobjidl_core-icustomdestinationlist-beginlist
+   * for more details.
+   *
+   * The returned Promise never rejects, but may report console errors in the
+   * event of removal failure.
+   *
+   * @param {string[]} uriSpecsToRemove
+   *   The URLs to be removed from Places history.
+   * @returns {Promise<undefined>}
+   */
+  _clearHistory(uriSpecsToRemove) {
+    let URIsToRemove = uriSpecsToRemove
+      .map(spec => {
+        try {
+          // in case we get a bad uri
+          return Services.io.newURI(spec);
+        } catch (e) {
+          return null;
+        }
+      })
+      .filter(uri => !!uri);
+
+    if (URIsToRemove.length) {
+      return lazy.PlacesUtils.history.remove(URIsToRemove).catch(console.error);
+    }
+    return Promise.resolve();
+  }
+};
+
+export var WinTaskbarJumpList = {
+  // We build two separate jump lists -- one for the regular Firefox icon
+  // and one for the Private Browsing icon
+  _builder: null,
+  _pbBuilder: null,
+  _builtPb: false,
+  _shuttingDown: false,
+  _useLegacyBackend: true,
+
+  /**
+   * Startup, shutdown, and update
+   */
+
+  startup: async function WTBJL_startup() {
+    // We do a one-time startup read of the backend pref here because
+    // we don't want to consider any bugs that occur if the pref is flipped
+    // at runtime. We want the pref flip to only take effect on a restart.
+    this._useLegacyBackend = lazy._prefs.getBoolPref(
+      PREF_TASKBAR_LEGACY_BACKEND
+    );
+
+    // exit if initting the taskbar failed for some reason.
+    if (!(await this._initTaskbar())) {
+      return;
+    }
+
+    if (lazy.PrivateBrowsingUtils.enabled) {
+      tasksCfg.push(privateWindowTask);
+    }
+    // Store our task list config data
+    this._builder._tasks = tasksCfg;
+    this._pbBuilder._tasks = tasksCfg;
+
+    // retrieve taskbar related prefs.
+    this._refreshPrefs();
+
+    // observer for private browsing and our prefs branch
+    this._initObs();
+
+    // jump list refresh timer
+    this._updateTimer();
+  },
+
+  update: function WTBJL_update() {
+    // are we disabled via prefs? don't do anything!
+    if (!this._enabled) {
+      return;
+    }
+
+    if (this._shuttingDown) {
+      return;
+    }
+
+    if (this._useLegacyBackend) {
+      // we only need to do this once, but we do it here
+      // to avoid main thread io on startup
+      if (!this._builtPb) {
+        this._pbBuilder.buildListLegacy();
+        this._builtPb = true;
+      }
+
+      // do what we came here to do, update the taskbar jumplist
+      this._builder.buildListLegacy();
+    } else {
+      this._builder.buildList();
+
+      // We only ever need to do this once because the private browsing window
+      // jumplist only ever shows the static task list, which never changes,
+      // so it doesn't need to be updated over time.
+      if (!this._builtPb) {
+        this._pbBuilder.buildList();
+        this._builtPb = true;
+      }
+    }
+  },
+
+  _shutdown: function WTBJL__shutdown() {
+    this._builder.updateShutdownState(true);
+    this._pbBuilder.updateShutdownState(true);
+    this._shuttingDown = true;
+    this._free();
+  },
+
+  /**
+   * Prefs utilities
+   */
+
+  _refreshPrefs: function WTBJL__refreshPrefs() {
+    this._enabled = lazy._prefs.getBoolPref(PREF_TASKBAR_ENABLED);
+    var showTasks = lazy._prefs.getBoolPref(PREF_TASKBAR_TASKS);
+    this._builder.refreshPrefs(
+      showTasks,
+      lazy._prefs.getBoolPref(PREF_TASKBAR_FREQUENT),
+      lazy._prefs.getBoolPref(PREF_TASKBAR_RECENT),
+      lazy._prefs.getIntPref(PREF_TASKBAR_ITEMCOUNT)
+    );
+    // showTasks is the only relevant pref for the Private Browsing Jump List
+    // the others are are related to frequent/recent entries, which are
+    // explicitly disabled for it
+    this._pbBuilder.refreshPrefs(showTasks, false, false, 0);
+  },
+
+  /**
+   * Init and shutdown utilities
+   */
+
+  _initTaskbar: async function WTBJL__initTaskbar() {
+    let builder;
+    let pbBuilder;
+
+    if (this._useLegacyBackend) {
+      builder = lazy._taskbarService.createLegacyJumpListBuilder(false);
+      pbBuilder = lazy._taskbarService.createLegacyJumpListBuilder(true);
+      if (
+        !builder ||
+        !builder.available ||
+        !pbBuilder ||
+        !pbBuilder.available
+      ) {
+        return false;
+      }
+    } else {
+      builder = lazy._taskbarService.createJumpListBuilder(false);
+      pbBuilder = lazy._taskbarService.createJumpListBuilder(true);
+      if (!builder || !pbBuilder) {
+        return false;
+      }
+      let [builderAvailable, pbBuilderAvailable] = await Promise.all([
+        builder.isAvailable(),
+        pbBuilder.isAvailable(),
+      ]);
+      if (!builderAvailable || !pbBuilderAvailable) {
+        return false;
+      }
+    }
+
+    this._builder = new Builder(builder);
+    this._pbBuilder = new Builder(pbBuilder);
+
+    return true;
+  },
+
+  _initObs: function WTBJL__initObs() {
+    // If the browser is closed while in private browsing mode, the "exit"
+    // notification is fired on quit-application-granted.
+    // History cleanup can happen at profile-change-teardown.
+    Services.obs.addObserver(this, "profile-before-change");
+    Services.obs.addObserver(this, "browser:purge-session-history");
+    lazy._prefs.addObserver("", this);
+    this._placesObserver = new PlacesWeakCallbackWrapper(
+      this.update.bind(this)
+    );
+    lazy.PlacesUtils.observers.addListener(
+      ["history-cleared"],
+      this._placesObserver
+    );
+  },
+
+  _freeObs: function WTBJL__freeObs() {
+    Services.obs.removeObserver(this, "profile-before-change");
+    Services.obs.removeObserver(this, "browser:purge-session-history");
+    lazy._prefs.removeObserver("", this);
+    if (this._placesObserver) {
+      lazy.PlacesUtils.observers.removeListener(
+        ["history-cleared"],
+        this._placesObserver
+      );
+    }
+  },
+
+  _updateTimer: function WTBJL__updateTimer() {
+    if (this._enabled && !this._shuttingDown && !this._timer) {
+      this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+      this._timer.initWithCallback(
+        this,
+        lazy._prefs.getIntPref(PREF_TASKBAR_REFRESH) * 1000,
+        this._timer.TYPE_REPEATING_SLACK
+      );
+    } else if ((!this._enabled || this._shuttingDown) && this._timer) {
+      this._timer.cancel();
+      delete this._timer;
+    }
+  },
+
+  _hasIdleObserver: false,
+  _updateIdleObserver: function WTBJL__updateIdleObserver() {
+    if (this._enabled && !this._shuttingDown && !this._hasIdleObserver) {
+      lazy._idle.addIdleObserver(this, IDLE_TIMEOUT_SECONDS);
+      this._hasIdleObserver = true;
+    } else if (
+      (!this._enabled || this._shuttingDown) &&
+      this._hasIdleObserver
+    ) {
+      lazy._idle.removeIdleObserver(this, IDLE_TIMEOUT_SECONDS);
+      this._hasIdleObserver = false;
+    }
+  },
+
+  _free: function WTBJL__free() {
+    this._freeObs();
+    this._updateTimer();
+    this._updateIdleObserver();
+    this._builder.delete();
+    this._pbBuilder.delete();
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsINamed",
+    "nsIObserver",
+    "nsITimerCallback",
+  ]),
+
+  name: "WinTaskbarJumpList",
+
+  notify: function WTBJL_notify(aTimer) {
+    // Add idle observer on the first notification so it doesn't hit startup.
+    this._updateIdleObserver();
+    Services.tm.idleDispatchToMainThread(() => {
+      this.update();
+    });
+  },
+
+  observe: function WTBJL_observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "nsPref:changed":
+        if (this._enabled && !lazy._prefs.getBoolPref(PREF_TASKBAR_ENABLED)) {
+          this._deleteActiveJumpList();
+        }
+        this._refreshPrefs();
+        this._updateTimer();
+        this._updateIdleObserver();
+        Services.tm.idleDispatchToMainThread(() => {
+          this.update();
+        });
+        break;
+
+      case "profile-before-change":
+        this._shutdown();
+        break;
+
+      case "browser:purge-session-history":
+        this.update();
+        break;
+      case "idle":
+        if (this._timer) {
+          this._timer.cancel();
+          delete this._timer;
+        }
+        break;
+
+      case "active":
+        this._updateTimer();
+        break;
+    }
+  },
+};
diff --git a/browser/modules/WindowsPreviewPerTab.sys.mjs b/browser/modules/WindowsPreviewPerTab.sys.mjs
new file mode 100644
index 0000000000..c0ef87fe8b
--- /dev/null
+++ b/browser/modules/WindowsPreviewPerTab.sys.mjs
@@ -0,0 +1,891 @@
+/* vim: se cin sw=2 ts=2 et filetype=javascript :
+ * 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/. */
+/*
+ * This module implements the front end behavior for AeroPeek. Starting in
+ * Windows Vista, the taskbar began showing live thumbnail previews of windows
+ * when the user hovered over the window icon in the taskbar. Starting with
+ * Windows 7, the taskbar allows an application to expose its tabbed interface
+ * in the taskbar by showing thumbnail previews rather than the default window
+ * preview. Additionally, when a user hovers over a thumbnail (tab or window),
+ * they are shown a live preview of the window (or tab + its containing window).
+ *
+ * In Windows 7, a title, icon, close button and optional toolbar are shown for
+ * each preview. This feature does not make use of the toolbar. For window
+ * previews, the title is the window title and the icon the window icon. For
+ * tab previews, the title is the page title and the page's favicon. In both
+ * cases, the close button "does the right thing."
+ *
+ * The primary objects behind this feature are nsITaskbarTabPreview and
+ * nsITaskbarPreviewController. Each preview has a controller. The controller
+ * responds to the user's interactions on the taskbar and provides the required
+ * data to the preview for determining the size of the tab and thumbnail. The
+ * PreviewController class implements this interface. The preview will request
+ * the controller to provide a thumbnail or preview when the user interacts with
+ * the taskbar. To reduce the overhead of drawing the tab area, the controller
+ * implementation caches the tab's contents in a <canvas> element. If no
+ * previews or thumbnails have been requested for some time, the controller will
+ * discard its cached tab contents.
+ *
+ * Screen real estate is limited so when there are too many thumbnails to fit
+ * on the screen, the taskbar stops displaying thumbnails and instead displays
+ * just the title, icon and close button in a similar fashion to previous
+ * versions of the taskbar. If there are still too many previews to fit on the
+ * screen, the taskbar resorts to a scroll up and scroll down button pair to let
+ * the user scroll through the list of tabs. Since this is undoubtedly
+ * inconvenient for users with many tabs, the AeroPeek objects turns off all of
+ * the tab previews. This tells the taskbar to revert to one preview per window.
+ * If the number of tabs falls below this magic threshold, the preview-per-tab
+ * behavior returns. There is no reliable way to determine when the scroll
+ * buttons appear on the taskbar, so a magic pref-controlled number determines
+ * when this threshold has been crossed.
+ */
+import { NetUtil } from "resource://gre/modules/NetUtil.sys.mjs";
+import { PlacesUtils } from "resource://gre/modules/PlacesUtils.sys.mjs";
+import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+// Pref to enable/disable preview-per-tab
+const TOGGLE_PREF_NAME = "browser.taskbar.previews.enable";
+// Pref to determine the magic auto-disable threshold
+const DISABLE_THRESHOLD_PREF_NAME = "browser.taskbar.previews.max";
+// Pref to control the time in seconds that tab contents live in the cache
+const CACHE_EXPIRATION_TIME_PREF_NAME = "browser.taskbar.previews.cachetime";
+
+const WINTASKBAR_CONTRACTID = "@mozilla.org/windows-taskbar;1";
+
+const lazy = {};
+
+// Various utility properties
+XPCOMUtils.defineLazyServiceGetter(
+  lazy,
+  "imgTools",
+  "@mozilla.org/image/tools;1",
+  "imgITools"
+);
+ChromeUtils.defineESModuleGetters(lazy, {
+  PageThumbs: "resource://gre/modules/PageThumbs.sys.mjs",
+});
+
+// nsIURI -> imgIContainer
+function _imageFromURI(uri, privateMode, callback) {
+  let channel = NetUtil.newChannel({
+    uri,
+    loadUsingSystemPrincipal: true,
+    contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE,
+  });
+
+  try {
+    channel.QueryInterface(Ci.nsIPrivateBrowsingChannel);
+    channel.setPrivate(privateMode);
+  } catch (e) {
+    // Ignore channels which do not support nsIPrivateBrowsingChannel
+  }
+  NetUtil.asyncFetch(channel, function (inputStream, resultCode) {
+    if (!Components.isSuccessCode(resultCode)) {
+      return;
+    }
+
+    const decodeCallback = {
+      onImageReady(image, status) {
+        if (!image) {
+          // We failed, so use the default favicon (only if this wasn't the
+          // default favicon).
+          let defaultURI = PlacesUtils.favicons.defaultFavicon;
+          if (!defaultURI.equals(uri)) {
+            _imageFromURI(defaultURI, privateMode, callback);
+            return;
+          }
+        }
+
+        callback(image);
+      },
+    };
+
+    try {
+      let threadManager = Cc["@mozilla.org/thread-manager;1"].getService();
+      lazy.imgTools.decodeImageAsync(
+        inputStream,
+        channel.contentType,
+        decodeCallback,
+        threadManager.currentThread
+      );
+    } catch (e) {
+      // We failed, so use the default favicon (only if this wasn't the default
+      // favicon).
+      let defaultURI = PlacesUtils.favicons.defaultFavicon;
+      if (!defaultURI.equals(uri)) {
+        _imageFromURI(defaultURI, privateMode, callback);
+      }
+    }
+  });
+}
+
+// string? -> imgIContainer
+function getFaviconAsImage(iconurl, privateMode, callback) {
+  if (iconurl) {
+    _imageFromURI(NetUtil.newURI(iconurl), privateMode, callback);
+  } else {
+    _imageFromURI(PlacesUtils.favicons.defaultFavicon, privateMode, callback);
+  }
+}
+
+// PreviewController
+
+/*
+ * This class manages the behavior of thumbnails and previews. It has the following
+ * responsibilities:
+ * 1) responding to requests from Windows taskbar for a thumbnail or window
+ *    preview.
+ * 2) listens for dom events that result in a thumbnail or window preview needing
+ *    to be refresh, and communicates this to the taskbar.
+ * 3) Handles querying and returning to the taskbar new thumbnail or window
+ *    preview images through PageThumbs.
+ *
+ * @param win
+ *        The TabWindow (see below) that owns the preview that this controls
+ * @param tab
+ *        The <tab> that this preview is associated with
+ */
+function PreviewController(win, tab) {
+  this.win = win;
+  this.tab = tab;
+  this.linkedBrowser = tab.linkedBrowser;
+  this.preview = this.win.createTabPreview(this);
+
+  this.tab.addEventListener("TabAttrModified", this);
+
+  ChromeUtils.defineLazyGetter(this, "canvasPreview", function () {
+    let canvas = lazy.PageThumbs.createCanvas(this.win.win);
+    canvas.mozOpaque = true;
+    return canvas;
+  });
+}
+
+PreviewController.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsITaskbarPreviewController"]),
+
+  destroy() {
+    this.tab.removeEventListener("TabAttrModified", this);
+
+    // Break cycles, otherwise we end up leaking the window with everything
+    // attached to it.
+    delete this.win;
+    delete this.preview;
+  },
+
+  get wrappedJSObject() {
+    return this;
+  },
+
+  // Resizes the canvasPreview to 0x0, essentially freeing its memory.
+  resetCanvasPreview() {
+    this.canvasPreview.width = 0;
+    this.canvasPreview.height = 0;
+  },
+
+  /**
+   * Set the canvas dimensions.
+   */
+  resizeCanvasPreview(aRequestedWidth, aRequestedHeight) {
+    this.canvasPreview.width = aRequestedWidth;
+    this.canvasPreview.height = aRequestedHeight;
+  },
+
+  get browserDims() {
+    return this.tab.linkedBrowser.getBoundingClientRect();
+  },
+
+  cacheBrowserDims() {
+    let dims = this.browserDims;
+    this._cachedWidth = dims.width;
+    this._cachedHeight = dims.height;
+  },
+
+  testCacheBrowserDims() {
+    let dims = this.browserDims;
+    return this._cachedWidth == dims.width && this._cachedHeight == dims.height;
+  },
+
+  /**
+   * Capture a new thumbnail image for this preview. Called by the controller
+   * in response to a request for a new thumbnail image.
+   */
+  updateCanvasPreview(aFullScale) {
+    // Update our cached browser dims so that delayed resize
+    // events don't trigger another invalidation if this tab becomes active.
+    this.cacheBrowserDims();
+    AeroPeek.resetCacheTimer();
+    return lazy.PageThumbs.captureToCanvas(
+      this.linkedBrowser,
+      this.canvasPreview,
+      {
+        fullScale: aFullScale,
+      }
+    ).catch(console.error);
+    // If we're updating the canvas, then we're in the middle of a peek so
+    // don't discard the cache of previews.
+  },
+
+  updateTitleAndTooltip() {
+    let title = this.win.tabbrowser.getWindowTitleForBrowser(
+      this.linkedBrowser
+    );
+    this.preview.title = title;
+    this.preview.tooltip = title;
+  },
+
+  // nsITaskbarPreviewController
+
+  // window width and height, not browser
+  get width() {
+    return this.win.width;
+  },
+
+  // window width and height, not browser
+  get height() {
+    return this.win.height;
+  },
+
+  get thumbnailAspectRatio() {
+    let browserDims = this.browserDims;
+    // Avoid returning 0
+    let tabWidth = browserDims.width || 1;
+    // Avoid divide by 0
+    let tabHeight = browserDims.height || 1;
+    return tabWidth / tabHeight;
+  },
+
+  /**
+   * Responds to taskbar requests for window previews. Returns the results asynchronously
+   * through updateCanvasPreview.
+   *
+   * @param aTaskbarCallback nsITaskbarPreviewCallback results callback
+   */
+  requestPreview(aTaskbarCallback) {
+    // Grab a high res content preview
+    this.resetCanvasPreview();
+    this.updateCanvasPreview(true).then(aPreviewCanvas => {
+      let winWidth = this.win.width;
+      let winHeight = this.win.height;
+
+      let composite = lazy.PageThumbs.createCanvas(this.win.win);
+
+      // Use transparency, Aero glass is drawn black without it.
+      composite.mozOpaque = false;
+
+      let ctx = composite.getContext("2d");
+      let scale = this.win.win.devicePixelRatio;
+
+      composite.width = winWidth * scale;
+      composite.height = winHeight * scale;
+
+      ctx.save();
+      ctx.scale(scale, scale);
+
+      // Draw chrome. Note we currently do not get scrollbars for remote frames
+      // in the image above.
+      ctx.drawWindow(this.win.win, 0, 0, winWidth, winHeight, "rgba(0,0,0,0)");
+
+      // Draw the content are into the composite canvas at the right location.
+      ctx.drawImage(
+        aPreviewCanvas,
+        this.browserDims.x,
+        this.browserDims.y,
+        aPreviewCanvas.width,
+        aPreviewCanvas.height
+      );
+      ctx.restore();
+
+      // Deliver the resulting composite canvas to Windows
+      this.win.tabbrowser.previewTab(this.tab, function () {
+        aTaskbarCallback.done(composite, false);
+      });
+    });
+  },
+
+  /**
+   * Responds to taskbar requests for tab thumbnails. Returns the results asynchronously
+   * through updateCanvasPreview.
+   *
+   * Note Windows requests a specific width and height here, if the resulting thumbnail
+   * does not match these dimensions thumbnail display will fail.
+   *
+   * @param aTaskbarCallback nsITaskbarPreviewCallback results callback
+   * @param aRequestedWidth width of the requested thumbnail
+   * @param aRequestedHeight height of the requested thumbnail
+   */
+  requestThumbnail(aTaskbarCallback, aRequestedWidth, aRequestedHeight) {
+    this.resizeCanvasPreview(aRequestedWidth, aRequestedHeight);
+    this.updateCanvasPreview(false).then(aThumbnailCanvas => {
+      aTaskbarCallback.done(aThumbnailCanvas, false);
+    });
+  },
+
+  // Event handling
+
+  onClose() {
+    this.win.tabbrowser.removeTab(this.tab);
+  },
+
+  onActivate() {
+    this.win.tabbrowser.selectedTab = this.tab;
+
+    // Accept activation - this will restore the browser window
+    // if it's minimized
+    return true;
+  },
+
+  // EventListener
+  handleEvent(evt) {
+    switch (evt.type) {
+      case "TabAttrModified":
+        this.updateTitleAndTooltip();
+        break;
+    }
+  },
+};
+
+// TabWindow
+
+/*
+ * This class monitors a browser window for changes to its tabs
+ *
+ * @param win
+ *        The nsIDOMWindow browser window
+ */
+function TabWindow(win) {
+  this.win = win;
+  this.tabbrowser = win.gBrowser;
+
+  this.previews = new Map();
+
+  for (let i = 0; i < this.tabEvents.length; i++) {
+    this.tabbrowser.tabContainer.addEventListener(this.tabEvents[i], this);
+  }
+
+  for (let i = 0; i < this.winEvents.length; i++) {
+    this.win.addEventListener(this.winEvents[i], this);
+  }
+
+  this.tabbrowser.addTabsProgressListener(this);
+
+  AeroPeek.windows.push(this);
+  let tabs = this.tabbrowser.tabs;
+  for (let i = 0; i < tabs.length; i++) {
+    this.newTab(tabs[i]);
+  }
+
+  this.updateTabOrdering();
+  AeroPeek.checkPreviewCount();
+}
+
+TabWindow.prototype = {
+  _enabled: false,
+  _cachedWidth: 0,
+  _cachedHeight: 0,
+  tabEvents: ["TabOpen", "TabClose", "TabSelect", "TabMove"],
+  winEvents: ["resize"],
+
+  destroy() {
+    this._destroying = true;
+
+    let tabs = this.tabbrowser.tabs;
+
+    this.tabbrowser.removeTabsProgressListener(this);
+
+    for (let i = 0; i < this.winEvents.length; i++) {
+      this.win.removeEventListener(this.winEvents[i], this);
+    }
+
+    for (let i = 0; i < this.tabEvents.length; i++) {
+      this.tabbrowser.tabContainer.removeEventListener(this.tabEvents[i], this);
+    }
+
+    for (let i = 0; i < tabs.length; i++) {
+      this.removeTab(tabs[i]);
+    }
+
+    let idx = AeroPeek.windows.indexOf(this.win.gTaskbarTabGroup);
+    AeroPeek.windows.splice(idx, 1);
+    AeroPeek.checkPreviewCount();
+  },
+
+  get width() {
+    return this.win.innerWidth;
+  },
+  get height() {
+    return this.win.innerHeight;
+  },
+
+  cacheDims() {
+    this._cachedWidth = this.width;
+    this._cachedHeight = this.height;
+  },
+
+  testCacheDims() {
+    return this._cachedWidth == this.width && this._cachedHeight == this.height;
+  },
+
+  // Invoked when the given tab is added to this window
+  newTab(tab) {
+    let controller = new PreviewController(this, tab);
+    // It's OK to add the preview now while the favicon still loads.
+    this.previews.set(tab, controller.preview);
+    AeroPeek.addPreview(controller.preview);
+    // updateTitleAndTooltip relies on having controller.preview which is lazily resolved.
+    // Now that we've updated this.previews, it will resolve successfully.
+    controller.updateTitleAndTooltip();
+  },
+
+  createTabPreview(controller) {
+    let docShell = this.win.docShell;
+    let preview = AeroPeek.taskbar.createTaskbarTabPreview(
+      docShell,
+      controller
+    );
+    preview.visible = AeroPeek.enabled;
+    let { tab } = controller;
+    preview.active = this.tabbrowser.selectedTab == tab;
+    this.updateFavicon(tab, tab.getAttribute("image"));
+    return preview;
+  },
+
+  // Invoked when the given tab is closed
+  removeTab(tab) {
+    let preview = this.previewFromTab(tab);
+    preview.active = false;
+    preview.visible = false;
+    preview.move(null);
+    preview.controller.wrappedJSObject.destroy();
+
+    this.previews.delete(tab);
+    AeroPeek.removePreview(preview);
+  },
+
+  get enabled() {
+    return this._enabled;
+  },
+
+  set enabled(enable) {
+    this._enabled = enable;
+    // Because making a tab visible requires that the tab it is next to be
+    // visible, it is far simpler to unset the 'next' tab and recreate them all
+    // at once.
+    for (let [, preview] of this.previews) {
+      preview.move(null);
+      preview.visible = enable;
+    }
+    this.updateTabOrdering();
+  },
+
+  previewFromTab(tab) {
+    return this.previews.get(tab);
+  },
+
+  updateTabOrdering() {
+    let previews = this.previews;
+    let tabs = this.tabbrowser.tabs;
+
+    // Previews are internally stored using a map, so we need to iterate the
+    // tabbrowser's array of tabs to retrieve previews in the same order.
+    let inorder = [];
+    for (let t of tabs) {
+      if (previews.has(t)) {
+        inorder.push(previews.get(t));
+      }
+    }
+
+    // Since the internal taskbar array has not yet been updated we must force
+    // on it the sorting order of our local array.  To do so we must walk
+    // the local array backwards, otherwise we would send move requests in the
+    // wrong order.  See bug 522610 for details.
+    for (let i = inorder.length - 1; i >= 0; i--) {
+      inorder[i].move(inorder[i + 1] || null);
+    }
+  },
+
+  // EventListener
+  handleEvent(evt) {
+    let tab = evt.originalTarget;
+    switch (evt.type) {
+      case "TabOpen":
+        this.newTab(tab);
+        this.updateTabOrdering();
+        break;
+      case "TabClose":
+        this.removeTab(tab);
+        this.updateTabOrdering();
+        break;
+      case "TabSelect":
+        this.previewFromTab(tab).active = true;
+        break;
+      case "TabMove":
+        this.updateTabOrdering();
+        break;
+      case "resize":
+        if (!AeroPeek._prefenabled) {
+          return;
+        }
+        this.onResize();
+        break;
+    }
+  },
+
+  // Set or reset a timer that will invalidate visible thumbnails soon.
+  setInvalidationTimer() {
+    if (!this.invalidateTimer) {
+      this.invalidateTimer = Cc["@mozilla.org/timer;1"].createInstance(
+        Ci.nsITimer
+      );
+    }
+    this.invalidateTimer.cancel();
+
+    // delay 1 second before invalidating
+    this.invalidateTimer.initWithCallback(
+      () => {
+        // invalidate every preview. note the internal implementation of
+        // invalidate ignores thumbnails that aren't visible.
+        this.previews.forEach(function (aPreview) {
+          let controller = aPreview.controller.wrappedJSObject;
+          if (!controller.testCacheBrowserDims()) {
+            controller.cacheBrowserDims();
+            aPreview.invalidate();
+          }
+        });
+      },
+      1000,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+  },
+
+  onResize() {
+    // Specific to a window.
+
+    // Call invalidate on each tab thumbnail so that Windows will request an
+    // updated image. However don't do this repeatedly across multiple resize
+    // events triggered during window border drags.
+
+    if (this.testCacheDims()) {
+      return;
+    }
+
+    // update the window dims on our TabWindow object.
+    this.cacheDims();
+
+    // invalidate soon
+    this.setInvalidationTimer();
+  },
+
+  invalidateTabPreview(aBrowser) {
+    for (let [tab, preview] of this.previews) {
+      if (aBrowser == tab.linkedBrowser) {
+        preview.invalidate();
+        break;
+      }
+    }
+  },
+
+  // Browser progress listener
+
+  onLocationChange(aBrowser) {
+    // I'm not sure we need this, onStateChange does a really good job
+    // of picking up page changes.
+    // this.invalidateTabPreview(aBrowser);
+  },
+
+  onStateChange(aBrowser, aWebProgress, aRequest, aStateFlags, aStatus) {
+    if (
+      aStateFlags & Ci.nsIWebProgressListener.STATE_STOP &&
+      aStateFlags & Ci.nsIWebProgressListener.STATE_IS_NETWORK
+    ) {
+      this.invalidateTabPreview(aBrowser);
+    }
+  },
+
+  onLinkIconAvailable(aBrowser, aIconURL) {
+    let tab = this.win.gBrowser.getTabForBrowser(aBrowser);
+    this.updateFavicon(tab, aIconURL);
+  },
+  updateFavicon(aTab, aIconURL) {
+    let requestURL = null;
+    if (aIconURL) {
+      try {
+        requestURL = PlacesUtils.favicons.getFaviconLinkForIcon(
+          Services.io.newURI(aIconURL)
+        ).spec;
+      } catch (ex) {
+        requestURL = aIconURL;
+      }
+    }
+    let isDefaultFavicon = !requestURL;
+    getFaviconAsImage(
+      requestURL,
+      PrivateBrowsingUtils.isWindowPrivate(this.win),
+      img => {
+        // The tab could have closed, and there's no guarantee the icons
+        // will have finished fetching 'in order'.
+        if (this.win.closed || aTab.closing || !aTab.linkedBrowser) {
+          return;
+        }
+        // Note that bizarrely, we can get to updateFavicon via a sync codepath
+        // where the new preview controller hasn't yet been added to the
+        // window's map of previews. So `preview` would be null here - except
+        // getFaviconAsImage is async so that should never happen, as we add
+        // the controller to the preview collection straight after creating it.
+        // However, if any of this code ever tries to access this
+        // synchronously, that won't work.
+        let preview = this.previews.get(aTab);
+        if (
+          aTab.getAttribute("image") == aIconURL ||
+          (!preview.icon && isDefaultFavicon)
+        ) {
+          preview.icon = img;
+        }
+      }
+    );
+  },
+};
+
+// AeroPeek
+
+/*
+ * This object acts as global storage and external interface for this feature.
+ * It maintains the values of the prefs.
+ */
+export var AeroPeek = {
+  available: false,
+  // Does the pref say we're enabled?
+  __prefenabled: false,
+
+  _enabled: true,
+
+  initialized: false,
+
+  // nsITaskbarTabPreview array
+  previews: [],
+
+  // TabWindow array
+  windows: [],
+
+  // nsIWinTaskbar service
+  taskbar: null,
+
+  // Maximum number of previews
+  maxpreviews: 20,
+
+  // Length of time in seconds that previews are cached
+  cacheLifespan: 20,
+
+  initialize() {
+    if (!(WINTASKBAR_CONTRACTID in Cc)) {
+      return;
+    }
+    this.taskbar = Cc[WINTASKBAR_CONTRACTID].getService(Ci.nsIWinTaskbar);
+    this.available = this.taskbar.available;
+    if (!this.available) {
+      return;
+    }
+
+    Services.prefs.addObserver(TOGGLE_PREF_NAME, this, true);
+    this.enabled = this._prefenabled =
+      Services.prefs.getBoolPref(TOGGLE_PREF_NAME);
+    this.initialized = true;
+  },
+
+  destroy: function destroy() {
+    this._enabled = false;
+
+    if (this.cacheTimer) {
+      this.cacheTimer.cancel();
+    }
+  },
+
+  get enabled() {
+    return this._enabled;
+  },
+
+  set enabled(enable) {
+    if (this._enabled == enable) {
+      return;
+    }
+
+    this._enabled = enable;
+
+    this.windows.forEach(function (win) {
+      win.enabled = enable;
+    });
+  },
+
+  get _prefenabled() {
+    return this.__prefenabled;
+  },
+
+  set _prefenabled(enable) {
+    if (enable == this.__prefenabled) {
+      return;
+    }
+    this.__prefenabled = enable;
+
+    if (enable) {
+      this.enable();
+    } else {
+      this.disable();
+    }
+  },
+
+  _observersAdded: false,
+
+  enable() {
+    if (!this._observersAdded) {
+      Services.prefs.addObserver(DISABLE_THRESHOLD_PREF_NAME, this, true);
+      Services.prefs.addObserver(CACHE_EXPIRATION_TIME_PREF_NAME, this, true);
+      this._placesListener = this.handlePlacesEvents.bind(this);
+      PlacesUtils.observers.addListener(
+        ["favicon-changed"],
+        this._placesListener
+      );
+      this._observersAdded = true;
+    }
+
+    this.cacheLifespan = Services.prefs.getIntPref(
+      CACHE_EXPIRATION_TIME_PREF_NAME
+    );
+
+    this.maxpreviews = Services.prefs.getIntPref(DISABLE_THRESHOLD_PREF_NAME);
+
+    // If the user toggled us on/off while the browser was already up
+    // (rather than this code running on startup because the pref was
+    // already set to true), we must initialize previews for open windows:
+    if (this.initialized) {
+      for (let win of Services.wm.getEnumerator("navigator:browser")) {
+        if (!win.closed) {
+          this.onOpenWindow(win);
+        }
+      }
+    }
+  },
+
+  disable() {
+    while (this.windows.length) {
+      // We can't call onCloseWindow here because it'll bail if we're not
+      // enabled.
+      let tabWinObject = this.windows[0];
+      tabWinObject.destroy(); // This will remove us from the array.
+      delete tabWinObject.win.gTaskbarTabGroup; // Tidy up the window.
+    }
+    PlacesUtils.observers.removeListener(
+      ["favicon-changed"],
+      this._placesListener
+    );
+  },
+
+  addPreview(preview) {
+    this.previews.push(preview);
+    this.checkPreviewCount();
+  },
+
+  removePreview(preview) {
+    let idx = this.previews.indexOf(preview);
+    this.previews.splice(idx, 1);
+    this.checkPreviewCount();
+  },
+
+  checkPreviewCount() {
+    if (!this._prefenabled) {
+      return;
+    }
+    this.enabled = this.previews.length <= this.maxpreviews;
+  },
+
+  onOpenWindow(win) {
+    // This occurs when the taskbar service is not available (xp, vista)
+    if (!this.available || !this._prefenabled) {
+      return;
+    }
+
+    win.gTaskbarTabGroup = new TabWindow(win);
+  },
+
+  onCloseWindow(win) {
+    // This occurs when the taskbar service is not available (xp, vista)
+    if (!this.available || !this._prefenabled) {
+      return;
+    }
+
+    win.gTaskbarTabGroup.destroy();
+    delete win.gTaskbarTabGroup;
+
+    if (!this.windows.length) {
+      this.destroy();
+    }
+  },
+
+  resetCacheTimer() {
+    this.cacheTimer.cancel();
+    this.cacheTimer.init(
+      this,
+      1000 * this.cacheLifespan,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+  },
+
+  // nsIObserver
+  observe(aSubject, aTopic, aData) {
+    if (aTopic == "nsPref:changed" && aData == TOGGLE_PREF_NAME) {
+      this._prefenabled = Services.prefs.getBoolPref(TOGGLE_PREF_NAME);
+    }
+    if (!this._prefenabled) {
+      return;
+    }
+    switch (aTopic) {
+      case "nsPref:changed":
+        if (aData == CACHE_EXPIRATION_TIME_PREF_NAME) {
+          break;
+        }
+
+        if (aData == DISABLE_THRESHOLD_PREF_NAME) {
+          this.maxpreviews = Services.prefs.getIntPref(
+            DISABLE_THRESHOLD_PREF_NAME
+          );
+        }
+        // Might need to enable/disable ourselves
+        this.checkPreviewCount();
+        break;
+      case "timer-callback":
+        this.previews.forEach(function (preview) {
+          let controller = preview.controller.wrappedJSObject;
+          controller.resetCanvasPreview();
+        });
+        break;
+    }
+  },
+
+  handlePlacesEvents(events) {
+    for (let event of events) {
+      switch (event.type) {
+        case "favicon-changed": {
+          for (let win of this.windows) {
+            for (let [tab] of win.previews) {
+              if (tab.getAttribute("image") == event.faviconUrl) {
+                win.updateFavicon(tab, event.faviconUrl);
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsISupportsWeakReference",
+    "nsIObserver",
+  ]),
+};
+
+ChromeUtils.defineLazyGetter(AeroPeek, "cacheTimer", () =>
+  Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer)
+);
+
+AeroPeek.initialize();
diff --git a/browser/modules/ZoomUI.sys.mjs b/browser/modules/ZoomUI.sys.mjs
new file mode 100644
index 0000000000..2e32ba46ec
--- /dev/null
+++ b/browser/modules/ZoomUI.sys.mjs
@@ -0,0 +1,209 @@
+// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+/* 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/. */
+
+const gLoadContext = Cu.createLoadContext();
+const gContentPrefs = Cc["@mozilla.org/content-pref/service;1"].getService(
+  Ci.nsIContentPrefService2
+);
+const gZoomPropertyName = "browser.content.full-zoom";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  PanelMultiView: "resource:///modules/PanelMultiView.sys.mjs",
+});
+
+export var ZoomUI = {
+  init(aWindow) {
+    aWindow.addEventListener("EndSwapDocShells", onEndSwapDocShells, true);
+    aWindow.addEventListener("FullZoomChange", onZoomChange);
+    aWindow.addEventListener("TextZoomChange", onZoomChange);
+    aWindow.addEventListener(
+      "unload",
+      () => {
+        aWindow.removeEventListener(
+          "EndSwapDocShells",
+          onEndSwapDocShells,
+          true
+        );
+        aWindow.removeEventListener("FullZoomChange", onZoomChange);
+        aWindow.removeEventListener("TextZoomChange", onZoomChange);
+      },
+      { once: true }
+    );
+  },
+
+  /**
+   * Gets the global browser.content.full-zoom content preference.
+   *
+   * @returns Promise<prefValue>
+   *                  Resolves to the preference value (float) when done.
+   */
+  getGlobalValue() {
+    return new Promise(resolve => {
+      let cachedVal = gContentPrefs.getCachedGlobal(
+        gZoomPropertyName,
+        gLoadContext
+      );
+      if (cachedVal) {
+        // We've got cached information, though it may be we've cached
+        // an undefined value, or the cached info is invalid. To ensure
+        // a valid return, we opt to return the default 1.0 in the
+        // undefined and invalid cases.
+        resolve(parseFloat(cachedVal.value) || 1.0);
+        return;
+      }
+      // Otherwise, nothing is cached, so we must do a full lookup
+      // with  `gContentPrefs.getGlobal()`.
+      let value = 1.0;
+      gContentPrefs.getGlobal(gZoomPropertyName, gLoadContext, {
+        handleResult(pref) {
+          if (pref.value) {
+            value = parseFloat(pref.value);
+          }
+        },
+        handleCompletion(reason) {
+          resolve(value);
+        },
+        handleError(error) {
+          console.error(error);
+        },
+      });
+    });
+  },
+};
+
+function fullZoomLocationChangeObserver(aSubject, aTopic) {
+  // If the tab was the last one in its window and has been dragged to another
+  // window, the original browser's window will be unavailable here. Since that
+  // window is closing, we can just ignore this notification.
+  if (!aSubject.ownerGlobal) {
+    return;
+  }
+  updateZoomUI(aSubject, false);
+}
+Services.obs.addObserver(
+  fullZoomLocationChangeObserver,
+  "browser-fullZoom:location-change"
+);
+
+function onEndSwapDocShells(event) {
+  updateZoomUI(event.originalTarget);
+}
+
+function onZoomChange(event) {
+  let browser;
+  if (event.target.nodeType == event.target.DOCUMENT_NODE) {
+    // In non-e10s, the event is dispatched on the contentDocument
+    // so we need to jump through some hoops to get to the <xul:browser>.
+    let topDoc = event.target.defaultView.top.document;
+    if (!topDoc.documentElement) {
+      // In some events, such as loading synthetic documents, the
+      // documentElement will be null and we won't be able to find
+      // an associated browser.
+      return;
+    }
+    browser = topDoc.ownerGlobal.docShell.chromeEventHandler;
+  } else {
+    browser = event.originalTarget;
+  }
+  updateZoomUI(browser, true);
+}
+
+/**
+ * Updates zoom controls.
+ *
+ * @param {object} aBrowser The browser that the zoomed content resides in.
+ * @param {boolean} aAnimate Should be True for all cases unless the zoom
+ *   change is related to tab switching. Optional
+ */
+async function updateZoomUI(aBrowser, aAnimate = false) {
+  let win = aBrowser.ownerGlobal;
+  if (!win.gBrowser || win.gBrowser.selectedBrowser != aBrowser) {
+    return;
+  }
+
+  let appMenuZoomReset = lazy.PanelMultiView.getViewNode(
+    win.document,
+    "appMenu-zoomReset-button2"
+  );
+
+  // Exit early if UI elements aren't present.
+  if (!appMenuZoomReset) {
+    return;
+  }
+
+  let customizableZoomControls = win.document.getElementById("zoom-controls");
+  let customizableZoomReset = win.document.getElementById("zoom-reset-button");
+  let urlbarZoomButton = win.document.getElementById("urlbar-zoom-button");
+  let zoomFactor = Math.round(win.ZoomManager.zoom * 100);
+
+  let defaultZoom = Math.round((await ZoomUI.getGlobalValue()) * 100);
+
+  if (!win.gBrowser || win.gBrowser.selectedBrowser != aBrowser) {
+    // Because the CPS call is async, at this point the selected browser
+    // may have changed. We should re-check whether the browser for which we've
+    // been notified is still the selected browser and bail out if not.
+    // If the selected browser changed (again), we will have been called again
+    // with the "right" browser, and that'll update the zoom level.
+    return;
+  }
+
+  // Hide urlbar zoom button if zoom is at the default zoom level,
+  // if we're viewing an about:blank page with an empty/null
+  // principal, if the PDF viewer is currently open,
+  // or if the customizable control is in the toolbar.
+
+  urlbarZoomButton.hidden =
+    defaultZoom == zoomFactor ||
+    (aBrowser.currentURI.spec == "about:blank" &&
+      (!aBrowser.contentPrincipal ||
+        aBrowser.contentPrincipal.isNullPrincipal)) ||
+    (aBrowser.contentPrincipal &&
+      aBrowser.contentPrincipal.spec == "resource://pdf.js/web/viewer.html") ||
+    (customizableZoomControls &&
+      customizableZoomControls.getAttribute("cui-areatype") == "toolbar");
+
+  let label = win.gNavigatorBundle.getFormattedString("zoom-button.label", [
+    zoomFactor,
+  ]);
+  if (appMenuZoomReset) {
+    appMenuZoomReset.setAttribute("label", label);
+  }
+  if (customizableZoomReset) {
+    customizableZoomReset.setAttribute("label", label);
+  }
+  if (!urlbarZoomButton.hidden) {
+    if (aAnimate && !win.gReduceMotion) {
+      urlbarZoomButton.setAttribute("animate", "true");
+    } else {
+      urlbarZoomButton.removeAttribute("animate");
+    }
+    urlbarZoomButton.setAttribute("label", label);
+  }
+
+  win.FullZoom.updateCommands();
+}
+
+import { CustomizableUI } from "resource:///modules/CustomizableUI.sys.mjs";
+
+let customizationListener = {};
+customizationListener.onWidgetAdded =
+  customizationListener.onWidgetRemoved =
+  customizationListener.onWidgetMoved =
+    function (aWidgetId) {
+      if (aWidgetId == "zoom-controls") {
+        for (let window of CustomizableUI.windows) {
+          updateZoomUI(window.gBrowser.selectedBrowser);
+        }
+      }
+    };
+customizationListener.onWidgetReset = customizationListener.onWidgetUndoMove =
+  function (aWidgetNode) {
+    if (aWidgetNode.id == "zoom-controls") {
+      updateZoomUI(aWidgetNode.ownerGlobal.gBrowser.selectedBrowser);
+    }
+  };
+CustomizableUI.addListener(customizationListener);
diff --git a/browser/modules/metrics.yaml b/browser/modules/metrics.yaml
new file mode 100644
index 0000000000..ac4e0c6ef9
--- /dev/null
+++ b/browser/modules/metrics.yaml
@@ -0,0 +1,120 @@
+# 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/.
+
+# Adding a new metric? We have docs for that!
+# https://firefox-source-docs.mozilla.org/toolkit/components/glean/user/new_definitions_file.html
+
+---
+$schema: moz://mozilla.org/schemas/glean/metrics/2-0-0
+$tags:
+  - 'Firefox :: General'
+
+browser.engagement:
+  active_ticks:
+    type: counter
+    description: |
+      The number of five-second intervals ('ticks') the user was considered
+      'active'.
+
+      'active' means keyboard or mouse interaction with the application.
+      It doesn't take into account whether or not the window has focus or is in
+      the foreground, only if it is receiving these interaction events.
+
+      Migrated from Telemetry's `browser.engagement.active_ticks`.
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1376942  # Telemetry
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1545172  # Telemetry
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1741674
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1755050
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1781578
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1545172#c8
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1781578
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1811152#c5
+    data_sensitivity:
+      - interaction
+    notification_emails:
+      - loines@mozilla.com
+    expires: never
+    send_in_pings:
+      - baseline
+      - metrics
+    no_lint:
+      - BASELINE_PING
+
+  uri_count:
+    type: counter
+    description: |
+      The number of total non-unique http(s) URIs visited, including page
+      reloads, after the session has been restored. URIs on minimized or
+      background tabs may also be counted. Private browsing uris are included.
+
+      Migrated from Telemetry's
+      `browser.engagement.total_uri_count_normal_and_private_mode`.
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1535169  # Telemetry
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1741674
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1755050
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1781578
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1535169#c14
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1781578
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1811152#c5
+    data_sensitivity:
+      - interaction
+    notification_emails:
+      - loines@mozilla.com
+    expires: never
+    send_in_pings:
+      - baseline
+      - metrics
+    no_lint:
+      - BASELINE_PING
+
+  profile_count:
+    type: quantity
+    unit: profiles
+    description: |
+      Windows only count of the browser profiles on the current system. This
+      counts profiles that have been used across all Windows user accounts on
+      machine since this probe was added. The value persists across installs.
+      A value of 0 is reported if there is an error determining the correct
+      count. Unset on other platforms.
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1813195
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1647422#c8
+    data_sensitivity:
+      - technical
+    notification_emails:
+      - pmcmanis@mozilla.com
+      - rtestard@mozilla.com
+    send_in_pings:
+      - metrics
+    expires: never
+
+
+performance.interaction:
+  tab_switch_composite:
+    type: timing_distribution
+    time_unit: millisecond
+    telemetry_mirror: FX_TAB_SWITCH_COMPOSITE_E10S_MS
+    description: >
+      Time between tab selection and first composite of the tab content onto the
+      screen.
+      (Migrated from the geckoview metric of the same name.)
+    metadata:
+      tags:
+        - 'Firefox :: Tabbed Browser'
+    bugs:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1481704
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1529352
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1580077
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1877842
+    data_reviews:
+      - https://bugzilla.mozilla.org/show_bug.cgi?id=1580077#c10
+    notification_emails:
+      - mconley@mozilla.com
+      - perf-telemetry-alerts@mozilla.com
+    expires: never
diff --git a/browser/modules/moz.build b/browser/modules/moz.build
new file mode 100644
index 0000000000..99b6bfd56f
--- /dev/null
+++ b/browser/modules/moz.build
@@ -0,0 +1,160 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Firefox", "General")
+
+with Files("test/browser/*Telemetry*"):
+    BUG_COMPONENT = ("Toolkit", "Telemetry")
+
+with Files("test/browser/*ContentSearch*"):
+    BUG_COMPONENT = ("Firefox", "Search")
+
+with Files("test/browser/*PermissionUI*"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("test/browser/*SitePermissions*"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("test/browser/browser_UnsubmittedCrashHandler.js"):
+    BUG_COMPONENT = ("Toolkit", "Crash Reporting")
+
+with Files("test/browser/browser_taskbar_preview.js"):
+    BUG_COMPONENT = ("Firefox", "Shell Integration")
+
+with Files("test/browser/browser_urlBar_zoom.js"):
+    BUG_COMPONENT = ("Firefox", "General")
+
+with Files("test/unit/test_E10SUtils_nested_URIs.js"):
+    BUG_COMPONENT = ("Core", "Security: Process Sandboxing")
+
+with Files("test/unit/test_LaterRun.js"):
+    BUG_COMPONENT = ("Firefox", "Tours")
+
+with Files("test/unit/test_SitePermissions.js"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("AboutNewTab.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "New Tab Page")
+
+with Files("AsyncTabSwitcher.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tabbed Browser")
+
+with Files("NewTabPagePreloading.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tabbed Browser")
+
+with Files("BrowserWindowTracker.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "General")
+
+with Files("BrowserUsageTelemetry.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "General")
+
+with Files("ContentCrashHandlers.sys.mjs"):
+    BUG_COMPONENT = ("Toolkit", "Crash Reporting")
+
+with Files("EveryWindow.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "General")
+
+with Files("ExtensionsUI.sys.mjs"):
+    BUG_COMPONENT = ("WebExtensions", "General")
+
+with Files("LaterRun.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tours")
+
+with Files("OpenInTabsUtils.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tabbed Browser")
+
+with Files("PartnerLinkAttribution.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Search")
+
+with Files("PermissionUI.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("ProcessHangMonitor.sys.mjs"):
+    BUG_COMPONENT = ("Core", "DOM: Content Processes")
+
+with Files("Sanitizer.sys.mjs"):
+    BUG_COMPONENT = ("Toolkit", "Data Sanitization")
+
+with Files("SelectionChangedMenulist.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Settings UI")
+
+with Files("SiteDataManager.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Settings UI")
+
+with Files("SitePermissions.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("TabsList.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tabbed Browser")
+
+with Files("TabUnloader.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Tabbed Browser")
+
+with Files("TransientPrefs.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Settings UI")
+
+with Files("WindowsJumpLists.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Shell Integration")
+    SCHEDULES.exclusive = ["windows"]
+
+with Files("WindowsPreviewPerTab.sys.mjs"):
+    BUG_COMPONENT = ("Core", "Widget: Win32")
+    SCHEDULES.exclusive = ["windows"]
+
+with Files("webrtcUI.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Site Permissions")
+
+with Files("ZoomUI.sys.mjs"):
+    BUG_COMPONENT = ("Firefox", "Toolbars and Customization")
+
+BROWSER_CHROME_MANIFESTS += [
+    "test/browser/browser.toml",
+    "test/browser/formValidation/browser.toml",
+]
+XPCSHELL_TESTS_MANIFESTS += ["test/unit/xpcshell.toml"]
+
+EXTRA_JS_MODULES += [
+    "AboutNewTab.sys.mjs",
+    "AsyncTabSwitcher.sys.mjs",
+    "BrowserUIUtils.sys.mjs",
+    "BrowserUsageTelemetry.sys.mjs",
+    "BrowserWindowTracker.sys.mjs",
+    "ContentCrashHandlers.sys.mjs",
+    "Discovery.sys.mjs",
+    "EveryWindow.sys.mjs",
+    "ExtensionsUI.sys.mjs",
+    "FaviconLoader.sys.mjs",
+    "HomePage.sys.mjs",
+    "LaterRun.sys.mjs",
+    "NewTabPagePreloading.sys.mjs",
+    "OpenInTabsUtils.sys.mjs",
+    "PageActions.sys.mjs",
+    "PartnerLinkAttribution.sys.mjs",
+    "PermissionUI.sys.mjs",
+    "ProcessHangMonitor.sys.mjs",
+    "Sanitizer.sys.mjs",
+    "SelectionChangedMenulist.sys.mjs",
+    "SiteDataManager.sys.mjs",
+    "SitePermissions.sys.mjs",
+    "TabsList.sys.mjs",
+    "TabUnloader.sys.mjs",
+    "TransientPrefs.sys.mjs",
+    "URILoadingHelper.sys.mjs",
+    "webrtcUI.sys.mjs",
+    "ZoomUI.sys.mjs",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "windows":
+    EXTRA_JS_MODULES += [
+        "WindowsJumpLists.sys.mjs",
+        "WindowsPreviewPerTab.sys.mjs",
+    ]
+
+    EXTRA_JS_MODULES.backgroundtasks += [
+        "BackgroundTask_install.sys.mjs",
+        "BackgroundTask_uninstall.sys.mjs",
+    ]
diff --git a/browser/modules/test/browser/blank_iframe.html b/browser/modules/test/browser/blank_iframe.html
new file mode 100644
index 0000000000..88cd26088f
--- /dev/null
+++ b/browser/modules/test/browser/blank_iframe.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8"/>
+  </head>
+  <body><iframe></iframe></body>
+</html>
diff --git a/browser/modules/test/browser/browser.toml b/browser/modules/test/browser/browser.toml
new file mode 100644
index 0000000000..21b3cdf18c
--- /dev/null
+++ b/browser/modules/test/browser/browser.toml
@@ -0,0 +1,87 @@
+[DEFAULT]
+support-files = ["head.js"]
+prefs = ["telemetry.number_of_site_origin.min_interval=0"]
+
+["browser_BrowserWindowTracker.js"]
+
+["browser_EveryWindow.js"]
+
+["browser_HomePage_add_button.js"]
+
+["browser_PageActions.js"]
+
+["browser_PageActions_contextMenus.js"]
+
+["browser_PageActions_newWindow.js"]
+
+["browser_PermissionUI.js"]
+
+["browser_PermissionUI_prompts.js"]
+
+["browser_ProcessHangNotifications.js"]
+
+["browser_SitePermissions.js"]
+
+["browser_SitePermissions_combinations.js"]
+
+["browser_SitePermissions_expiry.js"]
+
+["browser_SitePermissions_tab_urls.js"]
+https_first_disabled = true
+
+["browser_TabUnloader.js"]
+support-files = [
+  "file_webrtc.html",
+  "../../../base/content/test/tabs/dummy_page.html",
+  "../../../base/content/test/tabs/file_mediaPlayback.html",
+  "../../../base/content/test/general/audio.ogg",
+]
+
+["browser_Telemetry_numberOfSiteOrigins.js"]
+support-files = ["contain_iframe.html"]
+
+["browser_Telemetry_numberOfSiteOriginsPerDocument.js"]
+support-files = [
+  "contain_iframe.html",
+  "blank_iframe.html",
+]
+
+["browser_UnsubmittedCrashHandler.js"]
+run-if = ["crashreporter"]
+
+["browser_UsageTelemetry.js"]
+https_first_disabled = true
+
+["browser_UsageTelemetry_content_aboutRestartRequired.js"]
+
+["browser_UsageTelemetry_domains.js"]
+https_first_disabled = true
+
+["browser_UsageTelemetry_interaction.js"]
+https_first_disabled = true
+
+["browser_UsageTelemetry_private_and_restore.js"]
+https_first_disabled = true
+skip-if = ["verify && debug"]
+
+["browser_UsageTelemetry_toolbars.js"]
+
+["browser_UsageTelemetry_uniqueOriginsVisitedInPast24Hours.js"]
+https_first_disabled = true
+
+["browser_preloading_tab_moving.js"]
+skip-if = ["os == 'linux' && tsan"] # Bug 1720203
+
+["browser_taskbar_preview.js"]
+skip-if = [
+  "os != 'win'",               # bug 1456807
+  "os == 'win' && bits == 64", # bug 1456807
+]
+
+["browser_urlBar_zoom.js"]
+skip-if = [
+  "os == 'mac'", # Bug 1528429
+  "os == 'linux' && bits == 64 && os_version == '18.04'", # Bug 1619835
+  "win10_2009 && bits == 64",           # Bug 1619835
+  "win11_2009 && bits == 32 && debug", # Bug 1619835
+]
diff --git a/browser/modules/test/browser/browser_BrowserWindowTracker.js b/browser/modules/test/browser/browser_BrowserWindowTracker.js
new file mode 100644
index 0000000000..ea6f75c0e3
--- /dev/null
+++ b/browser/modules/test/browser/browser_BrowserWindowTracker.js
@@ -0,0 +1,234 @@
+"use strict";
+
+const TEST_WINDOW = window;
+
+function windowActivated(win) {
+  if (Services.ww.activeWindow == win) {
+    return Promise.resolve();
+  }
+  return BrowserTestUtils.waitForEvent(win, "activate");
+}
+
+async function withOpenWindows(amount, cont) {
+  let windows = [];
+  for (let i = 0; i < amount; ++i) {
+    let win = await BrowserTestUtils.openNewBrowserWindow();
+    await windowActivated(win);
+    windows.push(win);
+  }
+  await cont(windows);
+  await Promise.all(
+    windows.map(window => BrowserTestUtils.closeWindow(window))
+  );
+}
+
+add_task(async function test_getTopWindow() {
+  await withOpenWindows(5, async function (windows) {
+    // Without options passed in.
+    let window = BrowserWindowTracker.getTopWindow();
+    let expectedMostRecentIndex = windows.length - 1;
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Last opened window should be the most recent one."
+    );
+
+    // Mess with the focused window things a bit.
+    for (let idx of [3, 1]) {
+      let promise = BrowserTestUtils.waitForEvent(windows[idx], "activate");
+      Services.focus.focusedWindow = windows[idx];
+      await promise;
+      window = BrowserWindowTracker.getTopWindow();
+      Assert.equal(
+        window,
+        windows[idx],
+        "Lastly focused window should be the most recent one."
+      );
+      // For this test it's useful to keep the array of created windows in order.
+      windows.splice(idx, 1);
+      windows.push(window);
+    }
+    // Update the pointer to the most recent opened window.
+    expectedMostRecentIndex = windows.length - 1;
+
+    // With 'private' option.
+    window = BrowserWindowTracker.getTopWindow({ private: true });
+    Assert.equal(window, null, "No private windows opened yet.");
+    window = BrowserWindowTracker.getTopWindow({ private: 1 });
+    Assert.equal(window, null, "No private windows opened yet.");
+    windows.push(
+      await BrowserTestUtils.openNewBrowserWindow({ private: true })
+    );
+    ++expectedMostRecentIndex;
+    window = BrowserWindowTracker.getTopWindow({ private: true });
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Private window available."
+    );
+    window = BrowserWindowTracker.getTopWindow({ private: 1 });
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Private window available."
+    );
+    // Private window checks seems to mysteriously fail on Linux in this test.
+    if (AppConstants.platform != "linux") {
+      window = BrowserWindowTracker.getTopWindow({ private: false });
+      Assert.equal(
+        window,
+        windows[expectedMostRecentIndex - 1],
+        "Private window available, but should not be returned."
+      );
+    }
+
+    // With 'allowPopups' option.
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: true });
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Window focused before the private window should be the most recent one."
+    );
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: false });
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Window focused before the private window should be the most recent one."
+    );
+    let popupWindowPromise = BrowserTestUtils.waitForNewWindow();
+    SpecialPowers.spawn(gBrowser.selectedBrowser, [], function () {
+      let features =
+        "location=no, personalbar=no, toolbar=no, scrollbars=no, menubar=no, status=no";
+      content.window.open("about:blank", "_blank", features);
+    });
+    let popupWindow = await popupWindowPromise;
+    await windowActivated(popupWindow);
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: true });
+    Assert.equal(
+      window,
+      popupWindow,
+      "The popup window should be the most recent one, when requested."
+    );
+    window = BrowserWindowTracker.getTopWindow({ allowPopups: false });
+    Assert.equal(
+      window,
+      windows[expectedMostRecentIndex],
+      "Window focused before the popup window should be the most recent one."
+    );
+    popupWindow.close();
+  });
+});
+
+add_task(async function test_orderedWindows() {
+  await withOpenWindows(10, async function (windows) {
+    Assert.equal(
+      BrowserWindowTracker.windowCount,
+      11,
+      "Number of tracked windows, including the test window"
+    );
+    let ordered = BrowserWindowTracker.orderedWindows.filter(
+      w => w != TEST_WINDOW
+    );
+    Assert.deepEqual(
+      [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+      ordered.map(w => windows.indexOf(w)),
+      "Order of opened windows should be as opened."
+    );
+
+    // Mess with the focused window things a bit.
+    for (let idx of [4, 6, 1]) {
+      let promise = BrowserTestUtils.waitForEvent(windows[idx], "activate");
+      Services.focus.focusedWindow = windows[idx];
+      await promise;
+    }
+
+    let ordered2 = BrowserWindowTracker.orderedWindows.filter(
+      w => w != TEST_WINDOW
+    );
+    // After the shuffle, we expect window '1' to be the top-most window, because
+    // it was the last one we called focus on. Then '6', the window we focused
+    // before-last, followed by '4'. The order of the other windows remains
+    // unchanged.
+    let expected = [1, 6, 4, 9, 8, 7, 5, 3, 2, 0];
+    Assert.deepEqual(
+      expected,
+      ordered2.map(w => windows.indexOf(w)),
+      "After shuffle of focused windows, the order should've changed."
+    );
+  });
+});
+
+add_task(async function test_pendingWindows() {
+  Assert.equal(
+    BrowserWindowTracker.windowCount,
+    1,
+    "Number of tracked windows, including the test window"
+  );
+
+  let pending = BrowserWindowTracker.getPendingWindow();
+  Assert.equal(pending, null, "Should be no pending window");
+
+  let expectedWin = BrowserWindowTracker.openWindow();
+  pending = BrowserWindowTracker.getPendingWindow();
+  Assert.ok(pending, "Should be a pending window now.");
+  Assert.ok(
+    !BrowserWindowTracker.getPendingWindow({ private: true }),
+    "Should not be a pending private window"
+  );
+  Assert.equal(
+    pending,
+    BrowserWindowTracker.getPendingWindow({ private: false }),
+    "Should be the same non-private window pending"
+  );
+
+  let foundWin = await pending;
+  Assert.equal(foundWin, expectedWin, "Should have found the right window");
+  Assert.ok(
+    !BrowserWindowTracker.getPendingWindow(),
+    "Should be no pending window now."
+  );
+
+  await BrowserTestUtils.closeWindow(foundWin);
+
+  expectedWin = BrowserWindowTracker.openWindow({ private: true });
+  pending = BrowserWindowTracker.getPendingWindow();
+  Assert.ok(pending, "Should be a pending window now.");
+  Assert.ok(
+    !BrowserWindowTracker.getPendingWindow({ private: false }),
+    "Should not be a pending non-private window"
+  );
+  Assert.equal(
+    pending,
+    BrowserWindowTracker.getPendingWindow({ private: true }),
+    "Should be the same private window pending"
+  );
+
+  foundWin = await pending;
+  Assert.equal(foundWin, expectedWin, "Should have found the right window");
+  Assert.ok(
+    !BrowserWindowTracker.getPendingWindow(),
+    "Should be no pending window now."
+  );
+
+  await BrowserTestUtils.closeWindow(foundWin);
+
+  expectedWin = Services.ww.openWindow(
+    null,
+    AppConstants.BROWSER_CHROME_URL,
+    "_blank",
+    "chrome,dialog=no,all",
+    null
+  );
+  BrowserWindowTracker.registerOpeningWindow(expectedWin, false);
+  pending = BrowserWindowTracker.getPendingWindow();
+  Assert.ok(pending, "Should be a pending window now.");
+
+  foundWin = await pending;
+  Assert.equal(foundWin, expectedWin, "Should have found the right window");
+  Assert.ok(
+    !BrowserWindowTracker.getPendingWindow(),
+    "Should be no pending window now."
+  );
+
+  await BrowserTestUtils.closeWindow(foundWin);
+});
diff --git a/browser/modules/test/browser/browser_EveryWindow.js b/browser/modules/test/browser/browser_EveryWindow.js
new file mode 100644
index 0000000000..de1a7bbf9a
--- /dev/null
+++ b/browser/modules/test/browser/browser_EveryWindow.js
@@ -0,0 +1,161 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+
+const { EveryWindow } = ChromeUtils.importESModule(
+  "resource:///modules/EveryWindow.sys.mjs"
+);
+
+async function windowInited(aId, aWin) {
+  // TestUtils.topicObserved returns [subject, data]. We return the
+  // subject, which in this case is the window.
+  return (
+    await TestUtils.topicObserved(`${aId}:init`, win => {
+      return aWin ? win == aWin : true;
+    })
+  )[0];
+}
+
+function windowUninited(aId, aWin, aClosing) {
+  return TestUtils.topicObserved(`${aId}:uninit`, (win, closing) => {
+    if (aWin && aWin != win) {
+      return false;
+    }
+    if (!aWin) {
+      return true;
+    }
+    if (!!aClosing != !!closing) {
+      return false;
+    }
+    return true;
+  });
+}
+
+function registerEWCallback(id) {
+  EveryWindow.registerCallback(
+    id,
+    win => {
+      Services.obs.notifyObservers(win, `${id}:init`);
+    },
+    (win, closing) => {
+      Services.obs.notifyObservers(win, `${id}:uninit`, closing);
+    }
+  );
+}
+
+function unregisterEWCallback(id, aCallUninit) {
+  EveryWindow.unregisterCallback(id, aCallUninit);
+}
+
+add_task(async function test_stuff() {
+  let win2 = await BrowserTestUtils.openNewBrowserWindow();
+  let win3 = await BrowserTestUtils.openNewBrowserWindow();
+
+  let callbackId1 = "EveryWindow:test:1";
+  let callbackId2 = "EveryWindow:test:2";
+
+  let initPromise = Promise.all([
+    windowInited(callbackId1, window),
+    windowInited(callbackId1, win2),
+    windowInited(callbackId1, win3),
+    windowInited(callbackId2, window),
+    windowInited(callbackId2, win2),
+    windowInited(callbackId2, win3),
+  ]);
+
+  registerEWCallback(callbackId1);
+  registerEWCallback(callbackId2);
+
+  await initPromise;
+  ok(true, "Init called for all existing windows for all registered consumers");
+
+  let uninitPromise = Promise.all([
+    windowUninited(callbackId1, window, false),
+    windowUninited(callbackId1, win2, false),
+    windowUninited(callbackId1, win3, false),
+    windowUninited(callbackId2, window, false),
+    windowUninited(callbackId2, win2, false),
+    windowUninited(callbackId2, win3, false),
+  ]);
+
+  unregisterEWCallback(callbackId1);
+  unregisterEWCallback(callbackId2);
+  await uninitPromise;
+  ok(true, "Uninit called for all existing windows");
+
+  initPromise = Promise.all([
+    windowInited(callbackId1, window),
+    windowInited(callbackId1, win2),
+    windowInited(callbackId1, win3),
+    windowInited(callbackId2, window),
+    windowInited(callbackId2, win2),
+    windowInited(callbackId2, win3),
+  ]);
+
+  registerEWCallback(callbackId1);
+  registerEWCallback(callbackId2);
+
+  await initPromise;
+  ok(true, "Init called for all existing windows for all registered consumers");
+
+  uninitPromise = Promise.all([
+    windowUninited(callbackId1, win2, true),
+    windowUninited(callbackId2, win2, true),
+  ]);
+  await BrowserTestUtils.closeWindow(win2);
+  await uninitPromise;
+  ok(
+    true,
+    "Uninit called with closing=true for win2 for all registered consumers"
+  );
+
+  uninitPromise = Promise.all([
+    windowUninited(callbackId1, win3, true),
+    windowUninited(callbackId2, win3, true),
+  ]);
+  await BrowserTestUtils.closeWindow(win3);
+  await uninitPromise;
+  ok(
+    true,
+    "Uninit called with closing=true for win3 for all registered consumers"
+  );
+
+  initPromise = windowInited(callbackId1);
+  let initPromise2 = windowInited(callbackId2);
+  win2 = await BrowserTestUtils.openNewBrowserWindow();
+  is(await initPromise, win2, "Init called for new window for callback 1");
+  is(await initPromise2, win2, "Init called for new window for callback 2");
+
+  uninitPromise = Promise.all([
+    windowUninited(callbackId1, win2, true),
+    windowUninited(callbackId2, win2, true),
+  ]);
+  await BrowserTestUtils.closeWindow(win2);
+  await uninitPromise;
+  ok(
+    true,
+    "Uninit called with closing=true for win2 for all registered consumers"
+  );
+
+  uninitPromise = windowUninited(callbackId1, window, false);
+  unregisterEWCallback(callbackId1);
+  await uninitPromise;
+  ok(
+    true,
+    "Uninit called for main window without closing flag for the unregistered consumer"
+  );
+
+  uninitPromise = windowUninited(callbackId2, window, false);
+  let timeoutPromise = new Promise(resolve => setTimeout(resolve, 500));
+  unregisterEWCallback(callbackId2, false);
+  let result = await Promise.race([uninitPromise, timeoutPromise]);
+  is(
+    result,
+    undefined,
+    "Uninit not called when unregistering a consumer with aCallUninit=false"
+  );
+});
diff --git a/browser/modules/test/browser/browser_HomePage_add_button.js b/browser/modules/test/browser/browser_HomePage_add_button.js
new file mode 100644
index 0000000000..c185b45a6b
--- /dev/null
+++ b/browser/modules/test/browser/browser_HomePage_add_button.js
@@ -0,0 +1,157 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  HomePage: "resource:///modules/HomePage.sys.mjs",
+});
+
+const kPrefHomePage = "browser.startup.homepage";
+const kPrefExtensionControlled =
+  "browser.startup.homepage_override.extensionControlled";
+const kPrefHomeButtonRemoved = "browser.engagement.home-button.has-removed";
+const kHomeButtonId = "home-button";
+const kUrlbarWidgetId = "urlbar-container";
+
+// eslint-disable-next-line no-empty-pattern
+async function withTestSetup({} = {}, testFn) {
+  CustomizableUI.removeWidgetFromArea(kHomeButtonId);
+
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      [kPrefHomeButtonRemoved, false],
+      [kPrefHomePage, "about:home"],
+      [kPrefExtensionControlled, false],
+    ],
+  });
+
+  HomePage._addCustomizableUiListener();
+
+  try {
+    await testFn();
+  } finally {
+    await SpecialPowers.popPrefEnv();
+    await CustomizableUI.reset();
+  }
+}
+
+function assertHomeButtonInArea(area) {
+  let placement = CustomizableUI.getPlacementOfWidget(kHomeButtonId);
+  is(placement.area, area, "home button in area");
+}
+
+function assertHomeButtonNotPlaced() {
+  ok(
+    !CustomizableUI.getPlacementOfWidget(kHomeButtonId),
+    "home button not placed"
+  );
+}
+
+function assertHasRemovedPref(val) {
+  is(
+    Services.prefs.getBoolPref(kPrefHomeButtonRemoved),
+    val,
+    "Expected removed pref value"
+  );
+}
+
+async function runAddButtonTest() {
+  await withTestSetup({}, async () => {
+    // Setting the homepage once should add to the toolbar.
+    assertHasRemovedPref(false);
+    assertHomeButtonNotPlaced();
+
+    await HomePage.set("https://example.com/");
+
+    assertHomeButtonInArea("nav-bar");
+    assertHasRemovedPref(false);
+
+    // After removing the home button, a new homepage shouldn't add it.
+    CustomizableUI.removeWidgetFromArea(kHomeButtonId);
+
+    await HomePage.set("https://mozilla.org/");
+    assertHomeButtonNotPlaced();
+  });
+}
+
+add_task(async function testAddHomeButtonOnSet() {
+  await runAddButtonTest();
+});
+
+add_task(async function testHomeButtonDoesNotMove() {
+  await withTestSetup({}, async () => {
+    // Setting the homepage should not move the home button.
+    CustomizableUI.addWidgetToArea(kHomeButtonId, "TabsToolbar");
+    assertHasRemovedPref(false);
+    assertHomeButtonInArea("TabsToolbar");
+
+    await HomePage.set("https://example.com/");
+
+    assertHasRemovedPref(false);
+    assertHomeButtonInArea("TabsToolbar");
+  });
+});
+
+add_task(async function testHomeButtonNotAddedBlank() {
+  await withTestSetup({}, async () => {
+    assertHomeButtonNotPlaced();
+    assertHasRemovedPref(false);
+
+    await HomePage.set("about:blank");
+
+    assertHasRemovedPref(false);
+    assertHomeButtonNotPlaced();
+
+    await HomePage.set("about:home");
+
+    assertHasRemovedPref(false);
+    assertHomeButtonNotPlaced();
+  });
+});
+
+add_task(async function testHomeButtonNotAddedExtensionControlled() {
+  await withTestSetup({}, async () => {
+    assertHomeButtonNotPlaced();
+    assertHasRemovedPref(false);
+    Services.prefs.setBoolPref(kPrefExtensionControlled, true);
+
+    await HomePage.set("https://search.example.com/?q=%s");
+
+    assertHomeButtonNotPlaced();
+  });
+});
+
+add_task(async function testHomeButtonPlacement() {
+  await withTestSetup({}, async () => {
+    assertHomeButtonNotPlaced();
+    HomePage._maybeAddHomeButtonToToolbar("https://example.com");
+    let homePlacement = CustomizableUI.getPlacementOfWidget(kHomeButtonId);
+    is(homePlacement.area, "nav-bar", "Home button is in the nav-bar");
+    is(homePlacement.position, 3, "Home button is after stop/refresh");
+
+    let addressBarPlacement =
+      CustomizableUI.getPlacementOfWidget(kUrlbarWidgetId);
+    is(
+      addressBarPlacement.position,
+      5,
+      "There's a space between home and urlbar"
+    );
+    CustomizableUI.removeWidgetFromArea(kHomeButtonId);
+    Services.prefs.setBoolPref(kPrefHomeButtonRemoved, false);
+
+    try {
+      CustomizableUI.addWidgetToArea(kUrlbarWidgetId, "nav-bar", 1);
+      HomePage._maybeAddHomeButtonToToolbar("https://example.com");
+      homePlacement = CustomizableUI.getPlacementOfWidget(kHomeButtonId);
+      is(homePlacement.area, "nav-bar", "Home button is in the nav-bar");
+      is(homePlacement.position, 1, "Home button is right before the urlbar");
+    } finally {
+      CustomizableUI.addWidgetToArea(
+        kUrlbarWidgetId,
+        addressBarPlacement.area,
+        addressBarPlacement.position
+      );
+    }
+  });
+});
diff --git a/browser/modules/test/browser/browser_PageActions.js b/browser/modules/test/browser/browser_PageActions.js
new file mode 100644
index 0000000000..4f86962a01
--- /dev/null
+++ b/browser/modules/test/browser/browser_PageActions.js
@@ -0,0 +1,1402 @@
+"use strict";
+
+// This is a test for PageActions.sys.mjs, specifically the generalized parts that
+// add and remove page actions and toggle them in the urlbar.  This does not
+// test the built-in page actions; browser_page_action_menu.js does that.
+
+// Initialization.  Must run first.
+add_setup(async function () {
+  // The page action urlbar button, and therefore the panel, is only shown when
+  // the current tab is actionable -- i.e., a normal web page.  about:blank is
+  // not, so open a new tab first thing, and close it when this test is done.
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: "http://example.com/",
+  });
+  registerCleanupFunction(async () => {
+    BrowserTestUtils.removeTab(tab);
+  });
+
+  await initPageActionsTest();
+});
+
+// Tests a simple non-built-in action without an iframe or subview.  Also
+// thoroughly checks most of the action's properties, methods, and DOM nodes, so
+// it's not necessary to do that in general in other test tasks.
+add_task(async function simple() {
+  let iconURL = "chrome://browser/skin/mail.svg";
+  let id = "test-simple";
+  let title = "Test simple";
+  let tooltip = "Test simple tooltip";
+
+  let onCommandCallCount = 0;
+  let onPlacedInPanelCallCount = 0;
+  let onPlacedInUrlbarCallCount = 0;
+  let onShowingInPanelCallCount = 0;
+  let onCommandExpectedButtonID;
+
+  let panelButtonID = BrowserPageActions.panelButtonNodeIDForActionID(id);
+  let urlbarButtonID = BrowserPageActions.urlbarButtonNodeIDForActionID(id);
+
+  // Open the panel so that actions are added to it, and then close it.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  let initialActions = PageActions.actions;
+  let initialActionsInPanel = PageActions.actionsInPanel(window);
+  let initialActionsInUrlbar = PageActions.actionsInUrlbar(window);
+
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      iconURL,
+      id,
+      title,
+      tooltip,
+      onCommand(event, buttonNode) {
+        onCommandCallCount++;
+        Assert.ok(event, "event should be non-null: " + event);
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, onCommandExpectedButtonID, "buttonNode.id");
+      },
+      onPlacedInPanel(buttonNode) {
+        onPlacedInPanelCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, panelButtonID, "buttonNode.id");
+      },
+      onPlacedInUrlbar(buttonNode) {
+        onPlacedInUrlbarCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, urlbarButtonID, "buttonNode.id");
+      },
+      onShowingInPanel(buttonNode) {
+        onShowingInPanelCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, panelButtonID, "buttonNode.id");
+      },
+    })
+  );
+
+  Assert.equal(action.getIconURL(), iconURL, "iconURL");
+  Assert.equal(action.id, id, "id");
+  Assert.equal(action.pinnedToUrlbar, true, "pinnedToUrlbar");
+  Assert.equal(action.getDisabled(), false, "disabled");
+  Assert.equal(action.getDisabled(window), false, "disabled in window");
+  Assert.equal(action.getTitle(), title, "title");
+  Assert.equal(action.getTitle(window), title, "title in window");
+  Assert.equal(action.getTooltip(), tooltip, "tooltip");
+  Assert.equal(action.getTooltip(window), tooltip, "tooltip in window");
+  Assert.equal(action.getWantsSubview(), false, "subview");
+  Assert.equal(action.getWantsSubview(window), false, "subview in window");
+  Assert.equal(action.urlbarIDOverride, null, "urlbarIDOverride");
+  Assert.equal(action.wantsIframe, false, "wantsIframe");
+
+  Assert.ok(!("__insertBeforeActionID" in action), "__insertBeforeActionID");
+  Assert.ok(!("__isSeparator" in action), "__isSeparator");
+  Assert.ok(!("__urlbarNodeInMarkup" in action), "__urlbarNodeInMarkup");
+  Assert.ok(!("__transient" in action), "__transient");
+
+  // The action shouldn't be placed in the panel until it opens for the first
+  // time.
+  Assert.equal(
+    onPlacedInPanelCallCount,
+    0,
+    "onPlacedInPanelCallCount should remain 0"
+  );
+  Assert.equal(
+    onPlacedInUrlbarCallCount,
+    1,
+    "onPlacedInUrlbarCallCount after adding the action"
+  );
+  Assert.equal(
+    onShowingInPanelCallCount,
+    0,
+    "onShowingInPanelCallCount should remain 0"
+  );
+
+  // Open the panel so that actions are added to it, and then close it.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  Assert.equal(
+    onPlacedInPanelCallCount,
+    1,
+    "onPlacedInPanelCallCount should be inc'ed"
+  );
+  Assert.equal(
+    onShowingInPanelCallCount,
+    1,
+    "onShowingInPanelCallCount should be inc'ed"
+  );
+
+  // Build an array of the expected actions in the panel and compare it to the
+  // actual actions.  Don't assume that there are or aren't already other non-
+  // built-in actions.
+  let sepIndex = initialActionsInPanel.findIndex(
+    a => a.id == PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+  );
+  let initialSepIndex = sepIndex;
+  let indexInPanel;
+  if (sepIndex < 0) {
+    // No prior non-built-in actions.
+    indexInPanel = initialActionsInPanel.length;
+  } else {
+    // Prior non-built-in actions.  Find the index where the action goes.
+    for (
+      indexInPanel = sepIndex + 1;
+      indexInPanel < initialActionsInPanel.length;
+      indexInPanel++
+    ) {
+      let a = initialActionsInPanel[indexInPanel];
+      if (a.getTitle().localeCompare(action.getTitle()) < 1) {
+        break;
+      }
+    }
+  }
+  let expectedActionsInPanel = initialActionsInPanel.slice();
+  expectedActionsInPanel.splice(indexInPanel, 0, action);
+  // The separator between the built-ins and non-built-ins should be present
+  // if it's not already.
+  if (sepIndex < 0) {
+    expectedActionsInPanel.splice(
+      indexInPanel,
+      0,
+      new PageActions.Action({
+        id: PageActions.ACTION_ID_BUILT_IN_SEPARATOR,
+        _isSeparator: true,
+      })
+    );
+    sepIndex = indexInPanel;
+    indexInPanel++;
+  }
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window),
+    expectedActionsInPanel,
+    "Actions in panel after adding the action"
+  );
+
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window),
+    [action].concat(initialActionsInUrlbar),
+    "Actions in urlbar after adding the action"
+  );
+
+  // Check the set of all actions.
+  Assert.deepEqual(
+    new Set(PageActions.actions),
+    new Set(initialActions.concat([action])),
+    "All actions after adding the action"
+  );
+
+  Assert.deepEqual(
+    PageActions.actionForID(action.id),
+    action,
+    "actionForID should be action"
+  );
+
+  Assert.ok(
+    PageActions._persistedActions.ids.includes(action.id),
+    "PageActions should record action in its list of seen actions"
+  );
+
+  // The action's panel button should have been created.
+  let panelButtonNode =
+    BrowserPageActions.mainViewBodyNode.children[indexInPanel];
+  Assert.notEqual(panelButtonNode, null, "panelButtonNode");
+  Assert.equal(panelButtonNode.id, panelButtonID, "panelButtonID");
+  Assert.equal(
+    panelButtonNode.getAttribute("label"),
+    action.getTitle(),
+    "label"
+  );
+
+  // The separator between the built-ins and non-built-ins should exist.
+  let sepNode = BrowserPageActions.mainViewBodyNode.children[sepIndex];
+  Assert.notEqual(sepNode, null, "sepNode");
+  Assert.equal(
+    sepNode.id,
+    BrowserPageActions.panelButtonNodeIDForActionID(
+      PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+    ),
+    "sepNode.id"
+  );
+
+  let urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(!!urlbarButtonNode, true, "urlbarButtonNode");
+
+  // Open the panel, click the action's button.
+  await promiseOpenPageActionPanel();
+  Assert.equal(
+    onShowingInPanelCallCount,
+    2,
+    "onShowingInPanelCallCount should be inc'ed"
+  );
+  onCommandExpectedButtonID = panelButtonID;
+  EventUtils.synthesizeMouseAtCenter(panelButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.equal(onCommandCallCount, 1, "onCommandCallCount should be inc'ed");
+
+  // Show the action's button in the urlbar.
+  action.pinnedToUrlbar = true;
+  Assert.equal(
+    onPlacedInUrlbarCallCount,
+    1,
+    "onPlacedInUrlbarCallCount should be inc'ed"
+  );
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.notEqual(urlbarButtonNode, null, "urlbarButtonNode");
+
+  // The button should have been inserted before the bookmark star.
+  Assert.notEqual(
+    urlbarButtonNode.nextElementSibling,
+    null,
+    "Should be a next node"
+  );
+  Assert.equal(
+    urlbarButtonNode.nextElementSibling.id,
+    PageActions.actionForID(PageActions.ACTION_ID_BOOKMARK).urlbarIDOverride,
+    "Next node should be the bookmark star"
+  );
+
+  // Disable the action.  The button in the urlbar should be removed, and the
+  // button in the panel should be disabled.
+  action.setDisabled(true);
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(urlbarButtonNode, null, "urlbar button should be removed");
+  Assert.equal(
+    panelButtonNode.disabled,
+    true,
+    "panel button should be disabled"
+  );
+
+  // Enable the action.  The button in the urlbar should be added back, and the
+  // button in the panel should be enabled.
+  action.setDisabled(false);
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.notEqual(urlbarButtonNode, null, "urlbar button should be added back");
+  Assert.equal(
+    panelButtonNode.disabled,
+    false,
+    "panel button should not be disabled"
+  );
+
+  // Click the urlbar button.
+  onCommandExpectedButtonID = urlbarButtonID;
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  Assert.equal(onCommandCallCount, 2, "onCommandCallCount should be inc'ed");
+
+  // Set a new title.
+  let newTitle = title + " new title";
+  action.setTitle(newTitle);
+  Assert.equal(action.getTitle(), newTitle, "New title");
+  Assert.equal(
+    panelButtonNode.getAttribute("label"),
+    action.getTitle(),
+    "New label"
+  );
+
+  // Now that pinnedToUrlbar has been toggled, make sure that it sticks across
+  // app restarts.  Simulate that by "unregistering" the action (not by removing
+  // it, which is more permanent) and then registering it again.
+
+  // unregister
+  PageActions._actionsByID.delete(action.id);
+  let index = PageActions._nonBuiltInActions.findIndex(a => a.id == action.id);
+  Assert.ok(index >= 0, "Action should be in _nonBuiltInActions to begin with");
+  PageActions._nonBuiltInActions.splice(index, 1);
+
+  // register again
+  PageActions._registerAction(action);
+
+  // check relevant properties
+  Assert.ok(
+    PageActions._persistedActions.ids.includes(action.id),
+    "PageActions should have 'seen' the action"
+  );
+  Assert.ok(
+    PageActions._persistedActions.idsInUrlbar.includes(action.id),
+    "idsInUrlbar should still include the action"
+  );
+  Assert.ok(action.pinnedToUrlbar, "pinnedToUrlbar should still be true");
+  Assert.ok(
+    action._pinnedToUrlbar,
+    "_pinnedToUrlbar should still be true, for good measure"
+  );
+
+  // Remove the action.
+  action.remove();
+  panelButtonNode = document.getElementById(panelButtonID);
+  Assert.equal(panelButtonNode, null, "panelButtonNode");
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(urlbarButtonNode, null, "urlbarButtonNode");
+
+  let separatorNode = document.getElementById(
+    BrowserPageActions.panelButtonNodeIDForActionID(
+      PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+    )
+  );
+  if (initialSepIndex < 0) {
+    // The separator between the built-in actions and non-built-in actions
+    // should be gone now, too.
+    Assert.equal(separatorNode, null, "No separator");
+    Assert.ok(
+      !BrowserPageActions.mainViewBodyNode.lastElementChild.localName.includes(
+        "separator"
+      ),
+      "Last child should not be separator"
+    );
+  } else {
+    // The separator should still be present.
+    Assert.notEqual(separatorNode, null, "Separator should still exist");
+  }
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window),
+    initialActionsInPanel,
+    "Actions in panel should go back to initial"
+  );
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window),
+    initialActionsInUrlbar,
+    "Actions in urlbar should go back to initial"
+  );
+  Assert.deepEqual(
+    PageActions.actions,
+    initialActions,
+    "Actions should go back to initial"
+  );
+  Assert.equal(
+    PageActions.actionForID(action.id),
+    null,
+    "actionForID should be null"
+  );
+
+  Assert.ok(
+    PageActions._persistedActions.ids.includes(action.id),
+    "Action ID should remain in cache until purged"
+  );
+  PageActions._purgeUnregisteredPersistedActions();
+  Assert.ok(
+    !PageActions._persistedActions.ids.includes(action.id),
+    "Action ID should be removed from cache after being purged"
+  );
+});
+
+// Tests a non-built-in action with a subview.
+add_task(async function withSubview() {
+  let id = "test-subview";
+
+  let onActionPlacedInPanelCallCount = 0;
+  let onActionPlacedInUrlbarCallCount = 0;
+  let onSubviewPlacedCount = 0;
+  let onSubviewShowingCount = 0;
+
+  let panelButtonID = BrowserPageActions.panelButtonNodeIDForActionID(id);
+  let urlbarButtonID = BrowserPageActions.urlbarButtonNodeIDForActionID(id);
+
+  let panelViewIDPanel = BrowserPageActions._panelViewNodeIDForActionID(
+    id,
+    false
+  );
+  let panelViewIDUrlbar = BrowserPageActions._panelViewNodeIDForActionID(
+    id,
+    true
+  );
+
+  let onSubviewPlacedExpectedPanelViewID = panelViewIDPanel;
+  let onSubviewShowingExpectedPanelViewID;
+
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      iconURL: "chrome://browser/skin/mail.svg",
+      id,
+      pinnedToUrlbar: true,
+      title: "Test subview",
+      wantsSubview: true,
+      onPlacedInPanel(buttonNode) {
+        onActionPlacedInPanelCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, panelButtonID, "buttonNode.id");
+      },
+      onPlacedInUrlbar(buttonNode) {
+        onActionPlacedInUrlbarCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, urlbarButtonID, "buttonNode.id");
+      },
+      onSubviewPlaced(panelViewNode) {
+        onSubviewPlacedCount++;
+        Assert.ok(
+          panelViewNode,
+          "panelViewNode should be non-null: " + panelViewNode
+        );
+        Assert.equal(
+          panelViewNode.id,
+          onSubviewPlacedExpectedPanelViewID,
+          "panelViewNode.id"
+        );
+      },
+      onSubviewShowing(panelViewNode) {
+        onSubviewShowingCount++;
+        Assert.ok(
+          panelViewNode,
+          "panelViewNode should be non-null: " + panelViewNode
+        );
+        Assert.equal(
+          panelViewNode.id,
+          onSubviewShowingExpectedPanelViewID,
+          "panelViewNode.id"
+        );
+      },
+    })
+  );
+
+  Assert.equal(action.id, id, "id");
+  Assert.equal(action.getWantsSubview(), true, "subview");
+  Assert.equal(action.getWantsSubview(window), true, "subview in window");
+
+  // The action shouldn't be placed in the panel until it opens for the first
+  // time.
+  Assert.equal(
+    onActionPlacedInPanelCallCount,
+    0,
+    "onActionPlacedInPanelCallCount should be 0"
+  );
+  Assert.equal(onSubviewPlacedCount, 0, "onSubviewPlacedCount should be 0");
+
+  // But it should be placed in the urlbar.
+  Assert.equal(
+    onActionPlacedInUrlbarCallCount,
+    1,
+    "onActionPlacedInUrlbarCallCount should be 0"
+  );
+
+  // Open the panel, which should place the action in it.
+  await promiseOpenPageActionPanel();
+
+  Assert.equal(
+    onActionPlacedInPanelCallCount,
+    1,
+    "onActionPlacedInPanelCallCount should be inc'ed"
+  );
+  Assert.equal(
+    onSubviewPlacedCount,
+    1,
+    "onSubviewPlacedCount should be inc'ed"
+  );
+  Assert.equal(
+    onSubviewShowingCount,
+    0,
+    "onSubviewShowingCount should remain 0"
+  );
+
+  // The action's panel button and view (in the main page action panel) should
+  // have been created.
+  let panelButtonNode = document.getElementById(panelButtonID);
+  Assert.notEqual(panelButtonNode, null, "panelButtonNode");
+
+  // The action's urlbar button should have been created.
+  let urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.notEqual(urlbarButtonNode, null, "urlbarButtonNode");
+
+  // The button should have been inserted before the bookmark star.
+  Assert.notEqual(
+    urlbarButtonNode.nextElementSibling,
+    null,
+    "Should be a next node"
+  );
+  Assert.equal(
+    urlbarButtonNode.nextElementSibling.id,
+    PageActions.actionForID(PageActions.ACTION_ID_BOOKMARK).urlbarIDOverride,
+    "Next node should be the bookmark star"
+  );
+
+  // Click the action's button in the panel.  The subview should be shown.
+  Assert.equal(
+    onSubviewShowingCount,
+    0,
+    "onSubviewShowingCount should remain 0"
+  );
+  let subviewShownPromise = promisePageActionViewShown();
+  onSubviewShowingExpectedPanelViewID = panelViewIDPanel;
+  panelButtonNode.click();
+  await subviewShownPromise;
+
+  // Click the main button to hide the main panel.
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  // Click the action's urlbar button, which should open the activated-action
+  // panel showing the subview.
+  onSubviewPlacedExpectedPanelViewID = panelViewIDUrlbar;
+  onSubviewShowingExpectedPanelViewID = panelViewIDUrlbar;
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  await promisePanelShown(BrowserPageActions._activatedActionPanelID);
+  Assert.equal(
+    onSubviewPlacedCount,
+    2,
+    "onSubviewPlacedCount should be inc'ed"
+  );
+  Assert.equal(
+    onSubviewShowingCount,
+    2,
+    "onSubviewShowingCount should be inc'ed"
+  );
+
+  // Click the urlbar button again.  The activated-action panel should close.
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  assertActivatedPageActionPanelHidden();
+
+  // Remove the action.
+  action.remove();
+  panelButtonNode = document.getElementById(panelButtonID);
+  Assert.equal(panelButtonNode, null, "panelButtonNode");
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(urlbarButtonNode, null, "urlbarButtonNode");
+  let panelViewNodePanel = document.getElementById(panelViewIDPanel);
+  Assert.equal(panelViewNodePanel, null, "panelViewNodePanel");
+  let panelViewNodeUrlbar = document.getElementById(panelViewIDUrlbar);
+  Assert.equal(panelViewNodeUrlbar, null, "panelViewNodeUrlbar");
+});
+
+// Tests a non-built-in action with an iframe.
+add_task(async function withIframe() {
+  let id = "test-iframe";
+
+  let onCommandCallCount = 0;
+  let onPlacedInPanelCallCount = 0;
+  let onPlacedInUrlbarCallCount = 0;
+  let onIframeShowingCount = 0;
+
+  let panelButtonID = BrowserPageActions.panelButtonNodeIDForActionID(id);
+  let urlbarButtonID = BrowserPageActions.urlbarButtonNodeIDForActionID(id);
+
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      iconURL: "chrome://browser/skin/mail.svg",
+      id,
+      pinnedToUrlbar: true,
+      title: "Test iframe",
+      wantsIframe: true,
+      onCommand(event, buttonNode) {
+        onCommandCallCount++;
+      },
+      onIframeShowing(iframeNode, panelNode) {
+        onIframeShowingCount++;
+        Assert.ok(iframeNode, "iframeNode should be non-null: " + iframeNode);
+        Assert.equal(iframeNode.localName, "iframe", "iframe localName");
+        Assert.ok(panelNode, "panelNode should be non-null: " + panelNode);
+        Assert.equal(
+          panelNode.id,
+          BrowserPageActions._activatedActionPanelID,
+          "panelNode.id"
+        );
+      },
+      onPlacedInPanel(buttonNode) {
+        onPlacedInPanelCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, panelButtonID, "buttonNode.id");
+      },
+      onPlacedInUrlbar(buttonNode) {
+        onPlacedInUrlbarCallCount++;
+        Assert.ok(buttonNode, "buttonNode should be non-null: " + buttonNode);
+        Assert.equal(buttonNode.id, urlbarButtonID, "buttonNode.id");
+      },
+    })
+  );
+
+  Assert.equal(action.id, id, "id");
+  Assert.equal(action.wantsIframe, true, "wantsIframe");
+
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  Assert.equal(
+    onPlacedInPanelCallCount,
+    1,
+    "onPlacedInPanelCallCount should be inc'ed"
+  );
+  Assert.equal(
+    onPlacedInUrlbarCallCount,
+    1,
+    "onPlacedInUrlbarCallCount should be inc'ed"
+  );
+  Assert.equal(onIframeShowingCount, 0, "onIframeShowingCount should remain 0");
+  Assert.equal(onCommandCallCount, 0, "onCommandCallCount should remain 0");
+
+  // The action's panel button should have been created.
+  let panelButtonNode = document.getElementById(panelButtonID);
+  Assert.notEqual(panelButtonNode, null, "panelButtonNode");
+
+  // The action's urlbar button should have been created.
+  let urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.notEqual(urlbarButtonNode, null, "urlbarButtonNode");
+
+  // The button should have been inserted before the bookmark star.
+  Assert.notEqual(
+    urlbarButtonNode.nextElementSibling,
+    null,
+    "Should be a next node"
+  );
+  Assert.equal(
+    urlbarButtonNode.nextElementSibling.id,
+    PageActions.actionForID(PageActions.ACTION_ID_BOOKMARK).urlbarIDOverride,
+    "Next node should be the bookmark star"
+  );
+
+  // Open the panel, click the action's button.
+  await promiseOpenPageActionPanel();
+  Assert.equal(onIframeShowingCount, 0, "onIframeShowingCount should remain 0");
+  EventUtils.synthesizeMouseAtCenter(panelButtonNode, {});
+  await promisePanelShown(BrowserPageActions._activatedActionPanelID);
+  Assert.equal(onCommandCallCount, 1, "onCommandCallCount should be inc'ed");
+  Assert.equal(
+    onIframeShowingCount,
+    1,
+    "onIframeShowingCount should be inc'ed"
+  );
+
+  // The activated-action panel should have opened, anchored to the action's
+  // urlbar button.
+  let aaPanel = document.getElementById(
+    BrowserPageActions._activatedActionPanelID
+  );
+  Assert.notEqual(aaPanel, null, "activated-action panel");
+  Assert.equal(aaPanel.anchorNode.id, urlbarButtonID, "aaPanel.anchorNode.id");
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  assertActivatedPageActionPanelHidden();
+
+  // Click the action's urlbar button.
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  await promisePanelShown(BrowserPageActions._activatedActionPanelID);
+  Assert.equal(onCommandCallCount, 2, "onCommandCallCount should be inc'ed");
+  Assert.equal(
+    onIframeShowingCount,
+    2,
+    "onIframeShowingCount should be inc'ed"
+  );
+
+  // The activated-action panel should have opened, again anchored to the
+  // action's urlbar button.
+  aaPanel = document.getElementById(BrowserPageActions._activatedActionPanelID);
+  Assert.notEqual(aaPanel, null, "aaPanel");
+  Assert.equal(aaPanel.anchorNode.id, urlbarButtonID, "aaPanel.anchorNode.id");
+  EventUtils.synthesizeMouseAtCenter(urlbarButtonNode, {});
+  assertActivatedPageActionPanelHidden();
+
+  // Hide the action's button in the urlbar.
+  action.pinnedToUrlbar = false;
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(urlbarButtonNode, null, "urlbarButtonNode");
+
+  // Open the panel, click the action's button.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(panelButtonNode, {});
+  await promisePanelShown(BrowserPageActions._activatedActionPanelID);
+  Assert.equal(onCommandCallCount, 3, "onCommandCallCount should be inc'ed");
+  Assert.equal(
+    onIframeShowingCount,
+    3,
+    "onIframeShowingCount should be inc'ed"
+  );
+
+  // The activated-action panel should have opened, this time anchored to the
+  // main page action button in the urlbar.
+  aaPanel = document.getElementById(BrowserPageActions._activatedActionPanelID);
+  Assert.notEqual(aaPanel, null, "aaPanel");
+  Assert.equal(
+    aaPanel.anchorNode.id,
+    BrowserPageActions.mainButtonNode.id,
+    "aaPanel.anchorNode.id"
+  );
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  assertActivatedPageActionPanelHidden();
+
+  // Remove the action.
+  action.remove();
+  panelButtonNode = document.getElementById(panelButtonID);
+  Assert.equal(panelButtonNode, null, "panelButtonNode");
+  urlbarButtonNode = document.getElementById(urlbarButtonID);
+  Assert.equal(urlbarButtonNode, null, "urlbarButtonNode");
+});
+
+// Tests an action with the _insertBeforeActionID option set.
+add_task(async function insertBeforeActionID() {
+  let id = "test-insertBeforeActionID";
+  let panelButtonID = BrowserPageActions.panelButtonNodeIDForActionID(id);
+
+  let initialActions = PageActions.actionsInPanel(window);
+  let initialBuiltInActions = PageActions._builtInActions.slice();
+  let initialNonBuiltInActions = PageActions._nonBuiltInActions.slice();
+
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      id,
+      title: "Test insertBeforeActionID",
+      _insertBeforeActionID: PageActions.ACTION_ID_BOOKMARK_SEPARATOR,
+    })
+  );
+
+  Assert.equal(action.id, id, "id");
+  Assert.ok("__insertBeforeActionID" in action, "__insertBeforeActionID");
+  Assert.equal(
+    action.__insertBeforeActionID,
+    PageActions.ACTION_ID_BOOKMARK_SEPARATOR,
+    "action.__insertBeforeActionID"
+  );
+
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  let newActions = PageActions.actionsInPanel(window);
+  Assert.equal(
+    newActions.length,
+    initialActions.length + 1,
+    "PageActions.actions.length should be updated"
+  );
+  Assert.equal(
+    PageActions._builtInActions.length,
+    initialBuiltInActions.length + 1,
+    "PageActions._builtInActions.length should be updated"
+  );
+  Assert.equal(
+    PageActions._nonBuiltInActions.length,
+    initialNonBuiltInActions.length,
+    "PageActions._nonBuiltInActions.length should remain the same"
+  );
+
+  // The action's panel button should have been created.
+  let panelButtonNode = document.getElementById(panelButtonID);
+  Assert.notEqual(panelButtonNode, null, "panelButtonNode");
+
+  // The separator between the built-in and non-built-in actions should not have
+  // been created.
+  Assert.equal(
+    document.getElementById(
+      BrowserPageActions.panelButtonNodeIDForActionID(
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+      )
+    ),
+    null,
+    "Separator should be gone"
+  );
+
+  action.remove();
+});
+
+// Tests that the ordering in the panel of multiple non-built-in actions is
+// alphabetical.
+add_task(async function multipleNonBuiltInOrdering() {
+  let idPrefix = "test-multipleNonBuiltInOrdering-";
+  let titlePrefix = "Test multipleNonBuiltInOrdering ";
+
+  let initialActions = PageActions.actionsInPanel(window);
+  let initialBuiltInActions = PageActions._builtInActions.slice();
+  let initialNonBuiltInActions = PageActions._nonBuiltInActions.slice();
+
+  // Create some actions in an out-of-order order.
+  let actions = [2, 1, 4, 3].map(index => {
+    return PageActions.addAction(
+      new PageActions.Action({
+        id: idPrefix + index,
+        title: titlePrefix + index,
+      })
+    );
+  });
+
+  // + 1 for the separator between built-in and non-built-in actions.
+  Assert.equal(
+    PageActions.actionsInPanel(window).length,
+    initialActions.length + actions.length + 1,
+    "PageActions.actionsInPanel().length should be updated"
+  );
+
+  Assert.equal(
+    PageActions._builtInActions.length,
+    initialBuiltInActions.length,
+    "PageActions._builtInActions.length should be same"
+  );
+  Assert.equal(
+    PageActions._nonBuiltInActions.length,
+    initialNonBuiltInActions.length + actions.length,
+    "PageActions._nonBuiltInActions.length should be updated"
+  );
+
+  // Look at the final actions.length actions in PageActions.actions, from first
+  // to last.
+  for (let i = 0; i < actions.length; i++) {
+    let expectedIndex = i + 1;
+    let actualAction = PageActions._nonBuiltInActions[i];
+    Assert.equal(
+      actualAction.id,
+      idPrefix + expectedIndex,
+      "actualAction.id for index: " + i
+    );
+  }
+
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  // Check the button nodes in the panel.
+  let expectedIndex = 1;
+  let buttonNode = document.getElementById(
+    BrowserPageActions.panelButtonNodeIDForActionID(idPrefix + expectedIndex)
+  );
+  Assert.notEqual(buttonNode, null, "buttonNode");
+  Assert.notEqual(
+    buttonNode.previousElementSibling,
+    null,
+    "buttonNode.previousElementSibling"
+  );
+  Assert.equal(
+    buttonNode.previousElementSibling.id,
+    BrowserPageActions.panelButtonNodeIDForActionID(
+      PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+    ),
+    "buttonNode.previousElementSibling.id"
+  );
+  for (let i = 0; i < actions.length; i++) {
+    Assert.notEqual(buttonNode, null, "buttonNode at index: " + i);
+    Assert.equal(
+      buttonNode.id,
+      BrowserPageActions.panelButtonNodeIDForActionID(idPrefix + expectedIndex),
+      "buttonNode.id at index: " + i
+    );
+    buttonNode = buttonNode.nextElementSibling;
+    expectedIndex++;
+  }
+  Assert.equal(buttonNode, null, "Nothing should come after the last button");
+
+  for (let action of actions) {
+    action.remove();
+  }
+
+  // The separator between the built-in and non-built-in actions should be gone.
+  Assert.equal(
+    document.getElementById(
+      BrowserPageActions.panelButtonNodeIDForActionID(
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+      )
+    ),
+    null,
+    "Separator should be gone"
+  );
+});
+
+// Makes sure the panel is correctly updated when a non-built-in action is
+// added before the built-in actions; and when all built-in actions are removed
+// and added back.
+add_task(async function nonBuiltFirst() {
+  let initialActions = PageActions.actions;
+  let initialActionsInPanel = PageActions.actionsInPanel(window);
+
+  // Remove all actions.
+  for (let action of initialActions) {
+    action.remove();
+  }
+
+  // Check the actions.
+  Assert.deepEqual(
+    PageActions.actions.map(a => a.id),
+    [],
+    "PageActions.actions should be empty"
+  );
+  Assert.deepEqual(
+    PageActions._builtInActions.map(a => a.id),
+    [],
+    "PageActions._builtInActions should be empty"
+  );
+  Assert.deepEqual(
+    PageActions._nonBuiltInActions.map(a => a.id),
+    [],
+    "PageActions._nonBuiltInActions should be empty"
+  );
+
+  // Check the panel.
+  Assert.equal(
+    BrowserPageActions.mainViewBodyNode.children.length,
+    0,
+    "All nodes should be gone"
+  );
+
+  // Add a non-built-in action.
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      id: "test-nonBuiltFirst",
+      title: "Test nonBuiltFirst",
+    })
+  );
+
+  // Check the actions.
+  Assert.deepEqual(
+    PageActions.actions.map(a => a.id),
+    [action.id],
+    "Action should be in PageActions.actions"
+  );
+  Assert.deepEqual(
+    PageActions._builtInActions.map(a => a.id),
+    [],
+    "PageActions._builtInActions should be empty"
+  );
+  Assert.deepEqual(
+    PageActions._nonBuiltInActions.map(a => a.id),
+    [action.id],
+    "Action should be in PageActions._nonBuiltInActions"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    [BrowserPageActions.panelButtonNodeIDForActionID(action.id)],
+    "Action should be in panel"
+  );
+
+  // Now add back all the actions.
+  for (let a of initialActions) {
+    PageActions.addAction(a);
+  }
+
+  // Check the actions.
+  Assert.deepEqual(
+    new Set(PageActions.actions.map(a => a.id)),
+    new Set(initialActions.map(a => a.id).concat([action.id])),
+    "All actions should be in PageActions.actions"
+  );
+  Assert.deepEqual(
+    PageActions._builtInActions.map(a => a.id),
+    initialActions.filter(a => !a.__transient).map(a => a.id),
+    "PageActions._builtInActions should be initial actions"
+  );
+  Assert.deepEqual(
+    PageActions._nonBuiltInActions.map(a => a.id),
+    [action.id],
+    "PageActions._nonBuiltInActions should contain action"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_BUILT_IN_SEPARATOR], [action.id]),
+    "All actions should be in PageActions.actionsInPanel()"
+  );
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_BUILT_IN_SEPARATOR], [action.id])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Panel should contain all actions"
+  );
+
+  // Remove the test action.
+  action.remove();
+
+  // Check the actions.
+  Assert.deepEqual(
+    PageActions.actions.map(a => a.id),
+    initialActions.map(a => a.id),
+    "Action should no longer be in PageActions.actions"
+  );
+  Assert.deepEqual(
+    PageActions._builtInActions.map(a => a.id),
+    initialActions.filter(a => !a.__transient).map(a => a.id),
+    "PageActions._builtInActions should be initial actions"
+  );
+  Assert.deepEqual(
+    PageActions._nonBuiltInActions.map(a => a.id),
+    [],
+    "Action should no longer be in PageActions._nonBuiltInActions"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel.map(a => a.id),
+    "Action should no longer be in PageActions.actionsInPanel()"
+  );
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel.map(a =>
+      BrowserPageActions.panelButtonNodeIDForActionID(a.id)
+    ),
+    "Action should no longer be in panel"
+  );
+});
+
+// Adds an action, changes its placement in the urlbar to something non-default,
+// removes the action, and then adds it back.  Since the action was removed and
+// re-added without restarting the app (or more accurately without calling
+// PageActions._purgeUnregisteredPersistedActions), the action should remain in
+// persisted state and retain its last placement in the urlbar.
+add_task(async function removeRetainState() {
+  // Get the list of actions initially in the urlbar.
+  let initialActionsInUrlbar = PageActions.actionsInUrlbar(window);
+  Assert.ok(
+    !!initialActionsInUrlbar.length,
+    "This test expects there to be at least one action in the urlbar initially (like the bookmark star)"
+  );
+
+  // Add a test action.
+  let id = "test-removeRetainState";
+  let testAction = PageActions.addAction(
+    new PageActions.Action({
+      id,
+      title: "Test removeRetainState",
+    })
+  );
+
+  // Show its button in the urlbar.
+  testAction.pinnedToUrlbar = true;
+
+  // "Move" the test action to the front of the urlbar by toggling
+  // pinnedToUrlbar for all the other actions in the urlbar.
+  for (let action of initialActionsInUrlbar) {
+    action.pinnedToUrlbar = false;
+    action.pinnedToUrlbar = true;
+  }
+
+  // Check the actions in PageActions.actionsInUrlbar.
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window).map(a => a.id),
+    [testAction].concat(initialActionsInUrlbar).map(a => a.id),
+    "PageActions.actionsInUrlbar should be in expected order: testAction followed by all initial actions"
+  );
+
+  // Check the nodes in the urlbar.
+  let actualUrlbarNodeIDs = [];
+  for (
+    let node = BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    [testAction]
+      .concat(initialActionsInUrlbar)
+      .map(a => BrowserPageActions.urlbarButtonNodeIDForActionID(a.id)),
+    "urlbar nodes should be in expected order: testAction followed by all initial actions"
+  );
+
+  // Remove the test action.
+  testAction.remove();
+
+  // Check the actions in PageActions.actionsInUrlbar.
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window).map(a => a.id),
+    initialActionsInUrlbar.map(a => a.id),
+    "PageActions.actionsInUrlbar should be in expected order after removing test action: all initial actions"
+  );
+
+  // Check the nodes in the urlbar.
+  actualUrlbarNodeIDs = [];
+  for (
+    let node = BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    initialActionsInUrlbar.map(a =>
+      BrowserPageActions.urlbarButtonNodeIDForActionID(a.id)
+    ),
+    "urlbar nodes should be in expected order after removing test action: all initial actions"
+  );
+
+  // Add the test action again.
+  testAction = PageActions.addAction(
+    new PageActions.Action({
+      id,
+      title: "Test removeRetainState",
+    })
+  );
+
+  // Show its button in the urlbar again.
+  testAction.pinnedToUrlbar = true;
+
+  // Check the actions in PageActions.actionsInUrlbar.
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window).map(a => a.id),
+    [testAction].concat(initialActionsInUrlbar).map(a => a.id),
+    "PageActions.actionsInUrlbar should be in expected order after re-adding test action: testAction followed by all initial actions"
+  );
+
+  // Check the nodes in the urlbar.
+  actualUrlbarNodeIDs = [];
+  for (
+    let node = BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    [testAction]
+      .concat(initialActionsInUrlbar)
+      .map(a => BrowserPageActions.urlbarButtonNodeIDForActionID(a.id)),
+    "urlbar nodes should be in expected order after re-adding test action: testAction followed by all initial actions"
+  );
+
+  // Done, clean up.
+  testAction.remove();
+});
+
+// Tests transient actions.
+add_task(async function transient() {
+  let initialActionsInPanel = PageActions.actionsInPanel(window);
+
+  let onPlacedInPanelCount = 0;
+  let onBeforePlacedInWindowCount = 0;
+
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      id: "test-transient",
+      title: "Test transient",
+      _transient: true,
+      onPlacedInPanel(buttonNode) {
+        onPlacedInPanelCount++;
+      },
+      onBeforePlacedInWindow(win) {
+        onBeforePlacedInWindowCount++;
+      },
+    })
+  );
+
+  Assert.equal(action.__transient, true, "__transient");
+
+  Assert.equal(onPlacedInPanelCount, 0, "onPlacedInPanelCount should remain 0");
+  Assert.equal(
+    onBeforePlacedInWindowCount,
+    1,
+    "onBeforePlacedInWindowCount after adding transient action"
+  );
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_TRANSIENT_SEPARATOR, action.id]),
+    "PageActions.actionsInPanel() should be updated"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_TRANSIENT_SEPARATOR, action.id])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Actions in panel should be correct"
+  );
+
+  Assert.equal(
+    onPlacedInPanelCount,
+    1,
+    "onPlacedInPanelCount should be inc'ed"
+  );
+  Assert.equal(
+    onBeforePlacedInWindowCount,
+    1,
+    "onBeforePlacedInWindowCount should be inc'ed"
+  );
+
+  // Disable the action.  It should be removed from the panel.
+  action.setDisabled(true, window);
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel.map(a => a.id),
+    "PageActions.actionsInPanel() should revert to initial"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel.map(a =>
+      BrowserPageActions.panelButtonNodeIDForActionID(a.id)
+    ),
+    "Actions in panel should be correct"
+  );
+
+  // Enable the action.  It should be added back to the panel.
+  action.setDisabled(false, window);
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_TRANSIENT_SEPARATOR, action.id]),
+    "PageActions.actionsInPanel() should be updated"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_TRANSIENT_SEPARATOR, action.id])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Actions in panel should be correct"
+  );
+
+  Assert.equal(
+    onPlacedInPanelCount,
+    2,
+    "onPlacedInPanelCount should be inc'ed"
+  );
+  Assert.equal(
+    onBeforePlacedInWindowCount,
+    2,
+    "onBeforePlacedInWindowCount should be inc'ed"
+  );
+
+  // Add another non-built in but non-transient action.
+  let otherAction = PageActions.addAction(
+    new PageActions.Action({
+      id: "test-transient2",
+      title: "Test transient 2",
+    })
+  );
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR,
+        otherAction.id,
+        PageActions.ACTION_ID_TRANSIENT_SEPARATOR,
+        action.id,
+      ]),
+    "PageActions.actionsInPanel() should be updated"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR,
+        otherAction.id,
+        PageActions.ACTION_ID_TRANSIENT_SEPARATOR,
+        action.id,
+      ])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Actions in panel should be correct"
+  );
+
+  Assert.equal(
+    onPlacedInPanelCount,
+    2,
+    "onPlacedInPanelCount should remain the same"
+  );
+  Assert.equal(
+    onBeforePlacedInWindowCount,
+    2,
+    "onBeforePlacedInWindowCount should remain the same"
+  );
+
+  // Disable the action again.  It should be removed from the panel.
+  action.setDisabled(true, window);
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_BUILT_IN_SEPARATOR, otherAction.id]),
+    "PageActions.actionsInPanel() should be updated"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([PageActions.ACTION_ID_BUILT_IN_SEPARATOR, otherAction.id])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Actions in panel should be correct"
+  );
+
+  // Enable the action again.  It should be added back to the panel.
+  action.setDisabled(false, window);
+
+  Assert.deepEqual(
+    PageActions.actionsInPanel(window).map(a => a.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR,
+        otherAction.id,
+        PageActions.ACTION_ID_TRANSIENT_SEPARATOR,
+        action.id,
+      ]),
+    "PageActions.actionsInPanel() should be updated"
+  );
+
+  // Check the panel.
+  await promiseOpenPageActionPanel();
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+  Assert.deepEqual(
+    Array.from(BrowserPageActions.mainViewBodyNode.children, n => n.id),
+    initialActionsInPanel
+      .map(a => a.id)
+      .concat([
+        PageActions.ACTION_ID_BUILT_IN_SEPARATOR,
+        otherAction.id,
+        PageActions.ACTION_ID_TRANSIENT_SEPARATOR,
+        action.id,
+      ])
+      .map(id => BrowserPageActions.panelButtonNodeIDForActionID(id)),
+    "Actions in panel should be correct"
+  );
+
+  Assert.equal(
+    onPlacedInPanelCount,
+    3,
+    "onPlacedInPanelCount should be inc'ed"
+  );
+  Assert.equal(
+    onBeforePlacedInWindowCount,
+    3,
+    "onBeforePlacedInWindowCount should be inc'ed"
+  );
+
+  // Done, clean up.
+  action.remove();
+  otherAction.remove();
+});
diff --git a/browser/modules/test/browser/browser_PageActions_contextMenus.js b/browser/modules/test/browser/browser_PageActions_contextMenus.js
new file mode 100644
index 0000000000..378c55c706
--- /dev/null
+++ b/browser/modules/test/browser/browser_PageActions_contextMenus.js
@@ -0,0 +1,226 @@
+"use strict";
+
+// This is a test for PageActions.sys.mjs, specifically the context menus.
+
+ChromeUtils.defineESModuleGetters(this, {
+  ExtensionCommon: "resource://gre/modules/ExtensionCommon.sys.mjs",
+});
+
+// Initialization.  Must run first.
+add_setup(async function () {
+  // The page action urlbar button, and therefore the panel, is only shown when
+  // the current tab is actionable -- i.e., a normal web page.  about:blank is
+  // not, so open a new tab first thing, and close it when this test is done.
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: "http://example.com/",
+  });
+  registerCleanupFunction(async () => {
+    BrowserTestUtils.removeTab(tab);
+  });
+
+  await initPageActionsTest();
+});
+
+// Opens the context menu on a non-built-in action.  (The context menu for
+// built-in actions is tested in browser_page_action_menu.js.)
+add_task(async function contextMenu() {
+  // Add an extension with a page action so we can test its context menu.
+  let extension = ExtensionTestUtils.loadExtension({
+    manifest: {
+      name: "Page action test",
+      page_action: { show_matches: ["<all_urls>"] },
+    },
+    useAddonManager: "temporary",
+  });
+  await extension.startup();
+  let actionId = ExtensionCommon.makeWidgetId(extension.id);
+
+  // Open the main panel.
+  await promiseOpenPageActionPanel();
+  let panelButton = BrowserPageActions.panelButtonNodeForActionID(actionId);
+  let cxmenu = document.getElementById("pageActionContextMenu");
+
+  let contextMenuPromise;
+  let menuItems;
+
+  // Open the context menu again on the action's button in the panel. (The
+  // panel should still be open.)
+  contextMenuPromise = promisePanelShown("pageActionContextMenu");
+  EventUtils.synthesizeMouseAtCenter(panelButton, {
+    type: "contextmenu",
+    button: 2,
+  });
+  await contextMenuPromise;
+  menuItems = collectContextMenuItems();
+  Assert.deepEqual(makeMenuItemSpecs(menuItems), makeContextMenuItemSpecs());
+
+  // Click the "manage extension" context menu item. about:addons should open.
+  let manageItemIndex = 0;
+  contextMenuPromise = promisePanelHidden("pageActionContextMenu");
+  let aboutAddonsPromise = BrowserTestUtils.waitForNewTab(
+    gBrowser,
+    "about:addons"
+  );
+  cxmenu.activateItem(menuItems[manageItemIndex]);
+  let values = await Promise.all([aboutAddonsPromise, contextMenuPromise]);
+  let aboutAddonsTab = values[0];
+  BrowserTestUtils.removeTab(aboutAddonsTab);
+
+  // Wait for the urlbar button to become visible again after about:addons is
+  // closed and the test tab becomes selected.
+  await BrowserTestUtils.waitForCondition(() => {
+    return BrowserPageActions.urlbarButtonNodeForActionID(actionId);
+  }, "Waiting for urlbar button to be added back");
+
+  // Open the context menu on the action's urlbar button.
+  let urlbarButton = BrowserPageActions.urlbarButtonNodeForActionID(actionId);
+  contextMenuPromise = promisePanelShown("pageActionContextMenu");
+  EventUtils.synthesizeMouseAtCenter(urlbarButton, {
+    type: "contextmenu",
+    button: 2,
+  });
+  await contextMenuPromise;
+  menuItems = collectContextMenuItems();
+  Assert.deepEqual(makeMenuItemSpecs(menuItems), makeContextMenuItemSpecs());
+
+  // Click the "manage" context menu item. about:addons should open.
+  contextMenuPromise = promisePanelHidden("pageActionContextMenu");
+  aboutAddonsPromise = BrowserTestUtils.waitForNewTab(gBrowser, "about:addons");
+  cxmenu.activateItem(menuItems[manageItemIndex]);
+  values = await Promise.all([aboutAddonsPromise, contextMenuPromise]);
+  aboutAddonsTab = values[0];
+  BrowserTestUtils.removeTab(aboutAddonsTab);
+
+  // Wait for the urlbar button to become visible again after about:addons is
+  // closed and the test tab becomes selected.
+  await BrowserTestUtils.waitForCondition(() => {
+    return BrowserPageActions.urlbarButtonNodeForActionID(actionId);
+  }, "Waiting for urlbar button to be added back");
+
+  // Open the context menu on the action's urlbar button.
+  urlbarButton = BrowserPageActions.urlbarButtonNodeForActionID(actionId);
+  contextMenuPromise = promisePanelShown("pageActionContextMenu");
+  EventUtils.synthesizeMouseAtCenter(urlbarButton, {
+    type: "contextmenu",
+    button: 2,
+  });
+  await contextMenuPromise;
+  menuItems = collectContextMenuItems();
+  Assert.deepEqual(makeMenuItemSpecs(menuItems), makeContextMenuItemSpecs());
+
+  // Below we'll click the "remove extension" context menu item, which first
+  // opens a prompt using the prompt service and requires confirming the prompt.
+  // Set up a mock prompt service that returns 0 to indicate that the user
+  // pressed the OK button.
+  let { prompt } = Services;
+  let promptService = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]),
+    confirmEx() {
+      return 0;
+    },
+  };
+  Services.prompt = promptService;
+  registerCleanupFunction(() => {
+    Services.prompt = prompt;
+  });
+
+  // Now click the "remove extension" context menu item.
+  let removeItemIndex = manageItemIndex + 1;
+  contextMenuPromise = promisePanelHidden("pageActionContextMenu");
+  let promiseUninstalled = promiseAddonUninstalled(extension.id);
+  cxmenu.activateItem(menuItems[removeItemIndex]);
+  await contextMenuPromise;
+  await promiseUninstalled;
+  await extension.unload();
+  Services.prompt = prompt;
+
+  // urlbar tests that run after this one can break if the mouse is left over
+  // the area where the urlbar popup appears, which seems to happen due to the
+  // above synthesized mouse events.  Move it over the urlbar.
+  EventUtils.synthesizeMouseAtCenter(gURLBar.inputField, { type: "mousemove" });
+  gURLBar.focus();
+});
+
+// The context menu shouldn't open on separators in the panel.
+add_task(async function contextMenuOnSeparator() {
+  // Add a non-built-in action so the built-in separator will appear in the
+  // panel.
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      id: "contextMenuOnSeparator",
+      title: "contextMenuOnSeparator",
+      pinnedToUrlbar: true,
+    })
+  );
+
+  // Open the panel and get the built-in separator.
+  await promiseOpenPageActionPanel();
+  let separator = BrowserPageActions.panelButtonNodeForActionID(
+    PageActions.ACTION_ID_BUILT_IN_SEPARATOR
+  );
+  Assert.ok(separator, "The built-in separator should be in the panel");
+
+  // Context-click it.  popupshowing should be fired, but by the time the event
+  // reaches this listener, preventDefault should have been called on it.
+  let showingPromise = BrowserTestUtils.waitForEvent(
+    document.getElementById("pageActionContextMenu"),
+    "popupshowing",
+    false
+  );
+  EventUtils.synthesizeMouseAtCenter(separator, {
+    type: "contextmenu",
+    button: 2,
+  });
+  let event = await showingPromise;
+  Assert.ok(
+    event.defaultPrevented,
+    "defaultPrevented should be true on popupshowing event"
+  );
+
+  // Click the main button to hide the main panel.
+  EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+  await promisePageActionPanelHidden();
+
+  action.remove();
+
+  // urlbar tests that run after this one can break if the mouse is left over
+  // the area where the urlbar popup appears, which seems to happen due to the
+  // above synthesized mouse events.  Move it over the urlbar.
+  EventUtils.synthesizeMouseAtCenter(gURLBar.inputField, { type: "mousemove" });
+  gURLBar.focus();
+});
+
+function collectContextMenuItems() {
+  let contextMenu = document.getElementById("pageActionContextMenu");
+  return Array.prototype.filter.call(contextMenu.children, node => {
+    return window.getComputedStyle(node).visibility == "visible";
+  });
+}
+
+function makeMenuItemSpecs(elements) {
+  return elements.map(e =>
+    e.localName == "menuseparator" ? {} : { label: e.label }
+  );
+}
+
+function makeContextMenuItemSpecs() {
+  let items = [
+    { label: "Manage Extension\u2026" },
+    { label: "Remove Extension" },
+  ];
+  return items;
+}
+
+function promiseAddonUninstalled(addonId) {
+  return new Promise(resolve => {
+    let listener = {};
+    listener.onUninstalled = addon => {
+      if (addon.id == addonId) {
+        AddonManager.removeAddonListener(listener);
+        resolve();
+      }
+    };
+    AddonManager.addAddonListener(listener);
+  });
+}
diff --git a/browser/modules/test/browser/browser_PageActions_newWindow.js b/browser/modules/test/browser/browser_PageActions_newWindow.js
new file mode 100644
index 0000000000..ade50c6b2c
--- /dev/null
+++ b/browser/modules/test/browser/browser_PageActions_newWindow.js
@@ -0,0 +1,377 @@
+"use strict";
+
+// This is a test for PageActions.sys.mjs, specifically the generalized parts that
+// add and remove page actions and toggle them in the urlbar.  This does not
+// test the built-in page actions; browser_page_action_menu.js does that.
+
+// Initialization.  Must run first.
+add_setup(async function () {
+  await initPageActionsTest();
+});
+
+// Makes sure that urlbar nodes appear in the correct order in a new window.
+add_task(async function urlbarOrderNewWindow() {
+  // Make some new actions.
+  let actions = [0, 1, 2].map(i => {
+    return PageActions.addAction(
+      new PageActions.Action({
+        id: `test-urlbarOrderNewWindow-${i}`,
+        title: `Test urlbarOrderNewWindow ${i}`,
+        pinnedToUrlbar: true,
+      })
+    );
+  });
+
+  // Make sure PageActions knows they're inserted before the bookmark action in
+  // the urlbar.
+  Assert.deepEqual(
+    PageActions._persistedActions.idsInUrlbar.slice(
+      PageActions._persistedActions.idsInUrlbar.length - (actions.length + 1)
+    ),
+    actions.map(a => a.id).concat([PageActions.ACTION_ID_BOOKMARK]),
+    "PageActions._persistedActions.idsInUrlbar has new actions inserted"
+  );
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window)
+      .slice(PageActions.actionsInUrlbar(window).length - (actions.length + 1))
+      .map(a => a.id),
+    actions.map(a => a.id).concat([PageActions.ACTION_ID_BOOKMARK]),
+    "PageActions.actionsInUrlbar has new actions inserted"
+  );
+
+  // Reach into _persistedActions to move the new actions to the front of the
+  // urlbar, same as if the user moved them.  That way we can test that insert-
+  // before IDs are correctly non-null when the urlbar nodes are inserted in the
+  // new window below.
+  PageActions._persistedActions.idsInUrlbar.splice(
+    PageActions._persistedActions.idsInUrlbar.length - (actions.length + 1),
+    actions.length
+  );
+  for (let i = 0; i < actions.length; i++) {
+    PageActions._persistedActions.idsInUrlbar.splice(i, 0, actions[i].id);
+  }
+
+  // Save the right-ordered IDs to use below, just in case they somehow get
+  // changed when the new window opens, which shouldn't happen, but maybe
+  // there's bugs.
+  let ids = PageActions._persistedActions.idsInUrlbar.slice();
+
+  // Make sure that worked.
+  Assert.deepEqual(
+    ids.slice(0, actions.length),
+    actions.map(a => a.id),
+    "PageActions._persistedActions.idsInUrlbar now has new actions at front"
+  );
+
+  // _persistedActions will contain the IDs of test actions added and removed
+  // above (unless PageActions._purgeUnregisteredPersistedActions() was called
+  // for all of them, which it wasn't).  Filter them out because they should
+  // not appear in the new window (or any window at this point).
+  ids = ids.filter(id => PageActions.actionForID(id));
+
+  // Open the new window.
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+
+  // Collect its urlbar nodes.
+  let actualUrlbarNodeIDs = [];
+  for (
+    let node = win.BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+
+  // Now check that they're in the right order.
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    ids.map(id => win.BrowserPageActions.urlbarButtonNodeIDForActionID(id)),
+    "Expected actions in new window's urlbar"
+  );
+
+  // Done, clean up.
+  await BrowserTestUtils.closeWindow(win);
+  for (let action of actions) {
+    action.remove();
+  }
+});
+
+// Stores version-0 (unversioned actually) persisted actions and makes sure that
+// migrating to version 1 works.
+add_task(async function migrate1() {
+  // Add a test action so we can test a non-built-in action below.
+  let actionId = "test-migrate1";
+  PageActions.addAction(
+    new PageActions.Action({
+      id: actionId,
+      title: "Test migrate1",
+      pinnedToUrlbar: true,
+    })
+  );
+
+  // Add the bookmark action first to make sure it ends up last after migration.
+  // Also include a non-default action to make sure we're not accidentally
+  // testing default behavior.
+  let ids = [PageActions.ACTION_ID_BOOKMARK, actionId];
+  let persisted = ids.reduce(
+    (memo, id) => {
+      memo.ids[id] = true;
+      memo.idsInUrlbar.push(id);
+      return memo;
+    },
+    { ids: {}, idsInUrlbar: [] }
+  );
+
+  Services.prefs.setStringPref(
+    PageActions.PREF_PERSISTED_ACTIONS,
+    JSON.stringify(persisted)
+  );
+
+  // Migrate.
+  PageActions._loadPersistedActions();
+
+  Assert.equal(PageActions._persistedActions.version, 1, "Correct version");
+
+  // expected order
+  let orderedIDs = [actionId, PageActions.ACTION_ID_BOOKMARK];
+
+  // Check the ordering.
+  Assert.deepEqual(
+    PageActions._persistedActions.idsInUrlbar,
+    orderedIDs,
+    "PageActions._persistedActions.idsInUrlbar has right order"
+  );
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window).map(a => a.id),
+    orderedIDs,
+    "PageActions.actionsInUrlbar has right order"
+  );
+
+  // Open a new window.
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: win.gBrowser,
+    url: "http://example.com/",
+  });
+
+  // Collect its urlbar nodes.
+  let actualUrlbarNodeIDs = [];
+  for (
+    let node = win.BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+
+  // Now check that they're in the right order.
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    orderedIDs.map(id =>
+      win.BrowserPageActions.urlbarButtonNodeIDForActionID(id)
+    ),
+    "Expected actions in new window's urlbar"
+  );
+
+  // Done, clean up.
+  await BrowserTestUtils.closeWindow(win);
+  Services.prefs.clearUserPref(PageActions.PREF_PERSISTED_ACTIONS);
+  PageActions.actionForID(actionId).remove();
+});
+
+// Opens a new browser window and makes sure per-window state works right.
+add_task(async function perWindowState() {
+  // Add a test action.
+  let title = "Test perWindowState";
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      iconURL: "chrome://browser/skin/mail.svg",
+      id: "test-perWindowState",
+      pinnedToUrlbar: true,
+      title,
+    })
+  );
+
+  let actionsInUrlbar = PageActions.actionsInUrlbar(window);
+
+  // Open a new browser window and load an actionable page so that the action
+  // shows up in it.
+  let newWindow = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: newWindow.gBrowser,
+    url: "http://example.com/",
+  });
+
+  // Set a new title globally.
+  let newGlobalTitle = title + " new title";
+  action.setTitle(newGlobalTitle);
+  Assert.equal(action.getTitle(), newGlobalTitle, "Title: global");
+  Assert.equal(action.getTitle(window), newGlobalTitle, "Title: old window");
+  Assert.equal(action.getTitle(newWindow), newGlobalTitle, "Title: new window");
+
+  // Initialize panel nodes in the windows
+  document.getElementById("pageActionButton").click();
+  await BrowserTestUtils.waitForEvent(document, "popupshowing", true);
+  newWindow.document.getElementById("pageActionButton").click();
+  await BrowserTestUtils.waitForEvent(newWindow.document, "popupshowing", true);
+
+  // The action's panel button nodes should be updated in both windows.
+  let panelButtonID = BrowserPageActions.panelButtonNodeIDForActionID(
+    action.id
+  );
+  for (let win of [window, newWindow]) {
+    win.BrowserPageActions.placeLazyActionsInPanel();
+    let panelButtonNode = win.document.getElementById(panelButtonID);
+    Assert.equal(
+      panelButtonNode.getAttribute("label"),
+      newGlobalTitle,
+      "Panel button label should be global title"
+    );
+  }
+
+  // Set a new title in the new window.
+  let newPerWinTitle = title + " new title in new window";
+  action.setTitle(newPerWinTitle, newWindow);
+  Assert.equal(
+    action.getTitle(),
+    newGlobalTitle,
+    "Title: global should remain same"
+  );
+  Assert.equal(
+    action.getTitle(window),
+    newGlobalTitle,
+    "Title: old window should remain same"
+  );
+  Assert.equal(
+    action.getTitle(newWindow),
+    newPerWinTitle,
+    "Title: new window should be new"
+  );
+
+  // The action's panel button node should be updated in the new window but the
+  // same in the old window.
+  let panelButtonNode1 = document.getElementById(panelButtonID);
+  Assert.equal(
+    panelButtonNode1.getAttribute("label"),
+    newGlobalTitle,
+    "Panel button label in old window"
+  );
+  let panelButtonNode2 = newWindow.document.getElementById(panelButtonID);
+  Assert.equal(
+    panelButtonNode2.getAttribute("label"),
+    newPerWinTitle,
+    "Panel button label in new window"
+  );
+
+  // Disable the action in the new window.
+  action.setDisabled(true, newWindow);
+  Assert.equal(
+    action.getDisabled(),
+    false,
+    "Disabled: global should remain false"
+  );
+  Assert.equal(
+    action.getDisabled(window),
+    false,
+    "Disabled: old window should remain false"
+  );
+  Assert.equal(
+    action.getDisabled(newWindow),
+    true,
+    "Disabled: new window should be true"
+  );
+
+  // Check PageActions.actionsInUrlbar for each window.
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(window).map(a => a.id),
+    actionsInUrlbar.map(a => a.id),
+    "PageActions.actionsInUrlbar: old window should have all actions in urlbar"
+  );
+  Assert.deepEqual(
+    PageActions.actionsInUrlbar(newWindow).map(a => a.id),
+    actionsInUrlbar.map(a => a.id).filter(id => id != action.id),
+    "PageActions.actionsInUrlbar: new window should have all actions in urlbar except the test action"
+  );
+
+  // Check the urlbar nodes for the old window.
+  let actualUrlbarNodeIDs = [];
+  for (
+    let node = BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    actionsInUrlbar.map(a =>
+      BrowserPageActions.urlbarButtonNodeIDForActionID(a.id)
+    ),
+    "Old window should have all nodes in urlbar"
+  );
+
+  // Check the urlbar nodes for the new window.
+  actualUrlbarNodeIDs = [];
+  for (
+    let node = newWindow.BrowserPageActions.mainButtonNode.nextElementSibling;
+    node;
+    node = node.nextElementSibling
+  ) {
+    actualUrlbarNodeIDs.push(node.id);
+  }
+  Assert.deepEqual(
+    actualUrlbarNodeIDs,
+    actionsInUrlbar
+      .filter(a => a.id != action.id)
+      .map(a => BrowserPageActions.urlbarButtonNodeIDForActionID(a.id)),
+    "New window should have all nodes in urlbar except for the test action's"
+  );
+
+  // Done, clean up.
+  await BrowserTestUtils.closeWindow(newWindow);
+  action.remove();
+});
+
+add_task(async function action_disablePrivateBrowsing() {
+  let id = "testWidget";
+  let action = PageActions.addAction(
+    new PageActions.Action({
+      id,
+      disablePrivateBrowsing: true,
+      title: "title",
+      disabled: false,
+      pinnedToUrlbar: true,
+    })
+  );
+  // Open an actionable page so that the main page action button appears.
+  let url = "http://example.com/";
+  let privateWindow = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  await BrowserTestUtils.openNewForegroundTab(
+    privateWindow.gBrowser,
+    url,
+    true,
+    true
+  );
+
+  Assert.ok(action.canShowInWindow(window), "should show in default window");
+  Assert.ok(
+    !action.canShowInWindow(privateWindow),
+    "should not show in private browser"
+  );
+  Assert.ok(action.shouldShowInUrlbar(window), "should show in default urlbar");
+  Assert.ok(
+    !action.shouldShowInUrlbar(privateWindow),
+    "should not show in default urlbar"
+  );
+  Assert.ok(action.shouldShowInPanel(window), "should show in default urlbar");
+  Assert.ok(
+    !action.shouldShowInPanel(privateWindow),
+    "should not show in default urlbar"
+  );
+
+  action.remove();
+
+  privateWindow.close();
+});
diff --git a/browser/modules/test/browser/browser_PermissionUI.js b/browser/modules/test/browser/browser_PermissionUI.js
new file mode 100644
index 0000000000..8b66734093
--- /dev/null
+++ b/browser/modules/test/browser/browser_PermissionUI.js
@@ -0,0 +1,692 @@
+/**
+ * These tests test the ability for the PermissionUI module to open
+ * permission prompts to the user. It also tests to ensure that
+ * add-ons can introduce their own permission prompts.
+ */
+
+"use strict";
+
+const { PermissionUI } = ChromeUtils.importESModule(
+  "resource:///modules/PermissionUI.sys.mjs"
+);
+
+const { PermissionTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PermissionTestUtils.sys.mjs"
+);
+
+/**
+ * Tests the PermissionPromptForRequest prototype to ensure that a prompt
+ * can be displayed. Does not test permission handling.
+ */
+add_task(async function test_permission_prompt_for_request() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com/",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      const kTestMessage = "Test message";
+      let mainAction = {
+        label: "Main",
+        accessKey: "M",
+      };
+      let secondaryAction = {
+        label: "Secondary",
+        accessKey: "S",
+      };
+
+      let mockRequest = makeMockPermissionRequest(browser);
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get request() {
+          return mockRequest;
+        }
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction, secondaryAction];
+        }
+      }
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        kTestNotificationID,
+        browser
+      );
+      Assert.ok(notification, "Should have gotten the notification");
+
+      Assert.equal(
+        notification.message,
+        kTestMessage,
+        "Should be showing the right message"
+      );
+      Assert.equal(
+        notification.mainAction.label,
+        mainAction.label,
+        "The main action should have the right label"
+      );
+      Assert.equal(
+        notification.mainAction.accessKey,
+        mainAction.accessKey,
+        "The main action should have the right access key"
+      );
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].label,
+        secondaryAction.label,
+        "The secondary action should have the right label"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].accessKey,
+        secondaryAction.accessKey,
+        "The secondary action should have the right access key"
+      );
+      Assert.ok(
+        notification.options.displayURI.equals(mockRequest.principal.URI),
+        "Should be showing the URI of the requesting page"
+      );
+
+      let removePromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popuphidden"
+      );
+      notification.remove();
+      await removePromise;
+    }
+  );
+});
+
+/**
+ * Tests that if the PermissionPrompt sets displayURI to false in popupOptions,
+ * then there is no URI shown on the popupnotification.
+ */
+add_task(async function test_permission_prompt_for_popupOptions() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com/",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      const kTestMessage = "Test message";
+      let mainAction = {
+        label: "Main",
+        accessKey: "M",
+      };
+      let secondaryAction = {
+        label: "Secondary",
+        accessKey: "S",
+      };
+
+      let mockRequest = makeMockPermissionRequest(browser);
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get request() {
+          return mockRequest;
+        }
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction, secondaryAction];
+        }
+        get popupOptions() {
+          return {
+            displayURI: false,
+          };
+        }
+      }
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        kTestNotificationID,
+        browser
+      );
+
+      Assert.ok(
+        !notification.options.displayURI,
+        "Should not show the URI of the requesting page"
+      );
+
+      let removePromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popuphidden"
+      );
+      notification.remove();
+      await removePromise;
+    }
+  );
+});
+
+/**
+ * Tests that if the PermissionPrompt has the permissionKey
+ * set that permissions can be set properly by the user. Also
+ * ensures that callbacks for promptActions are properly fired.
+ */
+add_task(async function test_with_permission_key() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      const kTestMessage = "Test message";
+      const kTestPermissionKey = "test-permission-key";
+
+      let allowed = false;
+      let mainAction = {
+        label: "Allow",
+        accessKey: "M",
+        action: SitePermissions.ALLOW,
+        callback() {
+          allowed = true;
+        },
+      };
+
+      let denied = false;
+      let secondaryAction = {
+        label: "Deny",
+        accessKey: "D",
+        action: SitePermissions.BLOCK,
+        callback() {
+          denied = true;
+        },
+      };
+
+      let mockRequest = makeMockPermissionRequest(browser);
+      let principal = mockRequest.principal;
+      registerCleanupFunction(function () {
+        PermissionTestUtils.remove(principal.URI, kTestPermissionKey);
+      });
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get request() {
+          return mockRequest;
+        }
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get permissionKey() {
+          return kTestPermissionKey;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction, secondaryAction];
+        }
+        get popupOptions() {
+          return {
+            checkbox: {
+              label: "Remember this decision",
+              show: true,
+              checked: true,
+            },
+          };
+        }
+      }
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        kTestNotificationID,
+        browser
+      );
+      Assert.ok(notification, "Should have gotten the notification");
+
+      let curPerm = SitePermissions.getForPrincipal(
+        principal,
+        kTestPermissionKey,
+        browser
+      );
+      Assert.equal(
+        curPerm.state,
+        SitePermissions.UNKNOWN,
+        "Should be no permission set to begin with."
+      );
+
+      // First test denying the permission request without the checkbox checked.
+      let popupNotification = getPopupNotificationNode();
+      popupNotification.checkbox.checked = false;
+
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      await clickSecondaryAction();
+      curPerm = SitePermissions.getForPrincipal(
+        principal,
+        kTestPermissionKey,
+        browser
+      );
+      Assert.deepEqual(
+        curPerm,
+        {
+          state: SitePermissions.BLOCK,
+          scope: SitePermissions.SCOPE_TEMPORARY,
+        },
+        "Should have denied the action temporarily"
+      );
+      // Try getting the permission without passing the browser object (should fail).
+      curPerm = PermissionTestUtils.getPermissionObject(
+        principal.URI,
+        kTestPermissionKey
+      );
+      Assert.equal(
+        curPerm,
+        null,
+        "Should have made no permanent permission entry"
+      );
+      Assert.ok(denied, "The secondaryAction callback should have fired");
+      Assert.ok(!allowed, "The mainAction callback should not have fired");
+      Assert.ok(
+        mockRequest._cancelled,
+        "The request should have been cancelled"
+      );
+      Assert.ok(
+        !mockRequest._allowed,
+        "The request should not have been allowed"
+      );
+
+      // Clear the permission and pretend we never denied
+      SitePermissions.removeFromPrincipal(
+        principal,
+        kTestPermissionKey,
+        browser
+      );
+      denied = false;
+      mockRequest._cancelled = false;
+
+      // Bring the PopupNotification back up now...
+      shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+
+      // Test denying the permission request.
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      await clickSecondaryAction();
+      curPerm = PermissionTestUtils.getPermissionObject(
+        principal.URI,
+        kTestPermissionKey
+      );
+      Assert.equal(
+        curPerm.capability,
+        Services.perms.DENY_ACTION,
+        "Should have denied the action"
+      );
+      Assert.equal(curPerm.expireTime, 0, "Deny should be permanent");
+      Assert.ok(denied, "The secondaryAction callback should have fired");
+      Assert.ok(!allowed, "The mainAction callback should not have fired");
+      Assert.ok(
+        mockRequest._cancelled,
+        "The request should have been cancelled"
+      );
+      Assert.ok(
+        !mockRequest._allowed,
+        "The request should not have been allowed"
+      );
+
+      // Clear the permission and pretend we never denied
+      PermissionTestUtils.remove(principal.URI, kTestPermissionKey);
+      denied = false;
+      mockRequest._cancelled = false;
+
+      // Bring the PopupNotification back up now...
+      shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+
+      // Test allowing the permission request.
+      await clickMainAction();
+      curPerm = PermissionTestUtils.getPermissionObject(
+        principal.URI,
+        kTestPermissionKey
+      );
+      Assert.equal(
+        curPerm.capability,
+        Services.perms.ALLOW_ACTION,
+        "Should have allowed the action"
+      );
+      Assert.equal(curPerm.expireTime, 0, "Allow should be permanent");
+      Assert.ok(!denied, "The secondaryAction callback should not have fired");
+      Assert.ok(allowed, "The mainAction callback should have fired");
+      Assert.ok(
+        !mockRequest._cancelled,
+        "The request should not have been cancelled"
+      );
+      Assert.ok(mockRequest._allowed, "The request should have been allowed");
+    }
+  );
+});
+
+/**
+ * Tests that the onBeforeShow method will be called before
+ * the popup appears.
+ */
+add_task(async function test_on_before_show() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      const kTestMessage = "Test message";
+
+      let mainAction = {
+        label: "Test action",
+        accessKey: "T",
+      };
+
+      let mockRequest = makeMockPermissionRequest(browser);
+      let beforeShown = false;
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get request() {
+          return mockRequest;
+        }
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction];
+        }
+        get popupOptions() {
+          return {
+            checkbox: {
+              label: "Remember this decision",
+              show: true,
+              checked: true,
+            },
+          };
+        }
+        onBeforeShow() {
+          beforeShown = true;
+          return true;
+        }
+      }
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      Assert.ok(beforeShown, "Should have called onBeforeShown");
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        kTestNotificationID,
+        browser
+      );
+
+      let removePromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popuphidden"
+      );
+      notification.remove();
+      await removePromise;
+    }
+  );
+});
+
+/**
+ * Tests that we can open a PermissionPrompt without wrapping a
+ * nsIContentPermissionRequest.
+ */
+add_task(async function test_no_request() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      let allowed = false;
+      let mainAction = {
+        label: "Allow",
+        accessKey: "M",
+        callback() {
+          allowed = true;
+        },
+      };
+
+      let denied = false;
+      let secondaryAction = {
+        label: "Deny",
+        accessKey: "D",
+        callback() {
+          denied = true;
+        },
+      };
+
+      const kTestMessage = "Test message with no request";
+      let principal = browser.contentPrincipal;
+      let beforeShown = false;
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get principal() {
+          return principal;
+        }
+        get browser() {
+          return browser;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction, secondaryAction];
+        }
+        onBeforeShow() {
+          beforeShown = true;
+          return true;
+        }
+      }
+
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      Assert.ok(beforeShown, "Should have called onBeforeShown");
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        kTestNotificationID,
+        browser
+      );
+
+      Assert.equal(
+        notification.message,
+        kTestMessage,
+        "Should be showing the right message"
+      );
+      Assert.equal(
+        notification.mainAction.label,
+        mainAction.label,
+        "The main action should have the right label"
+      );
+      Assert.equal(
+        notification.mainAction.accessKey,
+        mainAction.accessKey,
+        "The main action should have the right access key"
+      );
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].label,
+        secondaryAction.label,
+        "The secondary action should have the right label"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].accessKey,
+        secondaryAction.accessKey,
+        "The secondary action should have the right access key"
+      );
+      Assert.ok(
+        notification.options.displayURI.equals(principal.URI),
+        "Should be showing the URI of the requesting page"
+      );
+
+      // First test denying the permission request.
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      await clickSecondaryAction();
+      Assert.ok(denied, "The secondaryAction callback should have fired");
+      Assert.ok(!allowed, "The mainAction callback should not have fired");
+
+      shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+
+      // Next test allowing the permission request.
+      await clickMainAction();
+      Assert.ok(allowed, "The mainAction callback should have fired");
+    }
+  );
+});
+
+/**
+ * Tests that when the tab is moved to a different window, the notification
+ * is transferred to the new window.
+ */
+add_task(async function test_window_swap() {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: "http://example.com",
+    },
+    async function (browser) {
+      const kTestNotificationID = "test-notification";
+      const kTestMessage = "Test message";
+
+      let mainAction = {
+        label: "Test action",
+        accessKey: "T",
+      };
+      let secondaryAction = {
+        label: "Secondary",
+        accessKey: "S",
+      };
+
+      let mockRequest = makeMockPermissionRequest(browser);
+      class TestPrompt extends PermissionUI.PermissionPromptForRequest {
+        get request() {
+          return mockRequest;
+        }
+        get notificationID() {
+          return kTestNotificationID;
+        }
+        get message() {
+          return kTestMessage;
+        }
+        get promptActions() {
+          return [mainAction, secondaryAction];
+        }
+      }
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      new TestPrompt().prompt();
+      await shownPromise;
+
+      let newWindowOpened = BrowserTestUtils.waitForNewWindow();
+      gBrowser.replaceTabWithWindow(gBrowser.selectedTab);
+      let newWindow = await newWindowOpened;
+      // We may have already opened the panel, because it was open before we moved the tab.
+      if (newWindow.PopupNotifications.panel.state != "open") {
+        shownPromise = BrowserTestUtils.waitForEvent(
+          newWindow.PopupNotifications.panel,
+          "popupshown"
+        );
+        new TestPrompt().prompt();
+        await shownPromise;
+      }
+
+      let notification = newWindow.PopupNotifications.getNotification(
+        kTestNotificationID,
+        newWindow.gBrowser.selectedBrowser
+      );
+      Assert.ok(notification, "Should have gotten the notification");
+
+      Assert.equal(
+        notification.message,
+        kTestMessage,
+        "Should be showing the right message"
+      );
+      Assert.equal(
+        notification.mainAction.label,
+        mainAction.label,
+        "The main action should have the right label"
+      );
+      Assert.equal(
+        notification.mainAction.accessKey,
+        mainAction.accessKey,
+        "The main action should have the right access key"
+      );
+      Assert.equal(
+        notification.secondaryActions.length,
+        1,
+        "There should only be 1 secondary action"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].label,
+        secondaryAction.label,
+        "The secondary action should have the right label"
+      );
+      Assert.equal(
+        notification.secondaryActions[0].accessKey,
+        secondaryAction.accessKey,
+        "The secondary action should have the right access key"
+      );
+      Assert.ok(
+        notification.options.displayURI.equals(mockRequest.principal.URI),
+        "Should be showing the URI of the requesting page"
+      );
+
+      await BrowserTestUtils.closeWindow(newWindow);
+    }
+  );
+});
diff --git a/browser/modules/test/browser/browser_PermissionUI_prompts.js b/browser/modules/test/browser/browser_PermissionUI_prompts.js
new file mode 100644
index 0000000000..777e5a4a86
--- /dev/null
+++ b/browser/modules/test/browser/browser_PermissionUI_prompts.js
@@ -0,0 +1,284 @@
+/**
+ * These tests test the ability for the PermissionUI module to open
+ * permission prompts to the user. It also tests to ensure that
+ * add-ons can introduce their own permission prompts.
+ */
+
+"use strict";
+
+const { PermissionUI } = ChromeUtils.importESModule(
+  "resource:///modules/PermissionUI.sys.mjs"
+);
+const { SITEPERMS_ADDON_PROVIDER_PREF } = ChromeUtils.importESModule(
+  "resource://gre/modules/addons/siteperms-addon-utils.sys.mjs"
+);
+
+// Tests that GeolocationPermissionPrompt works as expected
+add_task(async function test_geo_permission_prompt() {
+  await testPrompt(PermissionUI.GeolocationPermissionPrompt);
+});
+
+// Tests that GeolocationPermissionPrompt works as expected with local files
+add_task(async function test_geo_permission_prompt_local_file() {
+  await testPrompt(PermissionUI.GeolocationPermissionPrompt, true);
+});
+
+// Tests that XRPermissionPrompt works as expected
+add_task(async function test_xr_permission_prompt() {
+  await testPrompt(PermissionUI.XRPermissionPrompt);
+});
+
+// Tests that XRPermissionPrompt works as expected with local files
+add_task(async function test_xr_permission_prompt_local_file() {
+  await testPrompt(PermissionUI.XRPermissionPrompt, true);
+});
+
+// Tests that DesktopNotificationPermissionPrompt works as expected
+add_task(async function test_desktop_notification_permission_prompt() {
+  Services.prefs.setBoolPref(
+    "dom.webnotifications.requireuserinteraction",
+    false
+  );
+  Services.prefs.setBoolPref(
+    "permissions.desktop-notification.notNow.enabled",
+    true
+  );
+  await testPrompt(PermissionUI.DesktopNotificationPermissionPrompt);
+  Services.prefs.clearUserPref("dom.webnotifications.requireuserinteraction");
+  Services.prefs.clearUserPref(
+    "permissions.desktop-notification.notNow.enabled"
+  );
+});
+
+// Tests that PersistentStoragePermissionPrompt works as expected
+add_task(async function test_persistent_storage_permission_prompt() {
+  await testPrompt(PermissionUI.PersistentStoragePermissionPrompt);
+});
+
+// Tests that MidiPrompt works as expected
+add_task(async function test_midi_permission_prompt() {
+  if (Services.prefs.getBoolPref(SITEPERMS_ADDON_PROVIDER_PREF, false)) {
+    ok(
+      true,
+      "PermissionUI.MIDIPermissionPrompt uses SitePermsAddon install flow"
+    );
+    return;
+  }
+  await testPrompt(PermissionUI.MIDIPermissionPrompt);
+});
+
+// Tests that MidiPrompt works as expected with local files
+add_task(async function test_midi_permission_prompt_local_file() {
+  if (Services.prefs.getBoolPref(SITEPERMS_ADDON_PROVIDER_PREF, false)) {
+    ok(
+      true,
+      "PermissionUI.MIDIPermissionPrompt uses SitePermsAddon install flow"
+    );
+    return;
+  }
+  await testPrompt(PermissionUI.MIDIPermissionPrompt, true);
+});
+
+// Tests that StoragePermissionPrompt works as expected
+add_task(async function test_storage_access_permission_prompt() {
+  Services.prefs.setBoolPref("dom.storage_access.auto_grants", false);
+  await testPrompt(PermissionUI.StorageAccessPermissionPrompt);
+  Services.prefs.clearUserPref("dom.storage_access.auto_grants");
+});
+
+async function testPrompt(Prompt, useLocalFile = false) {
+  await BrowserTestUtils.withNewTab(
+    {
+      gBrowser,
+      url: useLocalFile ? `file://${PathUtils.tempDir}` : "http://example.com",
+    },
+    async function (browser) {
+      let mockRequest = makeMockPermissionRequest(browser);
+      let principal = mockRequest.principal;
+      let TestPrompt = new Prompt(mockRequest);
+      let { usePermissionManager, permissionKey } = TestPrompt;
+
+      registerCleanupFunction(function () {
+        if (permissionKey) {
+          SitePermissions.removeFromPrincipal(
+            principal,
+            permissionKey,
+            browser
+          );
+        }
+      });
+
+      let shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      TestPrompt.prompt();
+      await shownPromise;
+      let notification = PopupNotifications.getNotification(
+        TestPrompt.notificationID,
+        browser
+      );
+      Assert.ok(notification, "Should have gotten the notification");
+
+      let curPerm;
+      if (permissionKey) {
+        curPerm = SitePermissions.getForPrincipal(
+          principal,
+          permissionKey,
+          browser
+        );
+        Assert.equal(
+          curPerm.state,
+          SitePermissions.UNKNOWN,
+          "Should be no permission set to begin with."
+        );
+      }
+
+      // First test denying the permission request without the checkbox checked.
+      let popupNotification = getPopupNotificationNode();
+      popupNotification.checkbox.checked = false;
+
+      let isNotificationPrompt =
+        Prompt == PermissionUI.DesktopNotificationPermissionPrompt;
+
+      let expectedSecondaryActionsCount = isNotificationPrompt ? 2 : 1;
+      Assert.equal(
+        notification.secondaryActions.length,
+        expectedSecondaryActionsCount,
+        "There should only be " +
+          expectedSecondaryActionsCount +
+          " secondary action(s)"
+      );
+      await clickSecondaryAction();
+      if (permissionKey) {
+        curPerm = SitePermissions.getForPrincipal(
+          principal,
+          permissionKey,
+          browser
+        );
+        Assert.deepEqual(
+          curPerm,
+          {
+            state: SitePermissions.BLOCK,
+            scope: SitePermissions.SCOPE_TEMPORARY,
+          },
+          "Should have denied the action temporarily"
+        );
+
+        Assert.ok(
+          mockRequest._cancelled,
+          "The request should have been cancelled"
+        );
+        Assert.ok(
+          !mockRequest._allowed,
+          "The request should not have been allowed"
+        );
+      }
+
+      SitePermissions.removeFromPrincipal(
+        principal,
+        TestPrompt.permissionKey,
+        browser
+      );
+      mockRequest._cancelled = false;
+
+      // Bring the PopupNotification back up now...
+      shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      TestPrompt.prompt();
+      await shownPromise;
+
+      // Test denying the permission request with the checkbox checked (for geolocation)
+      // or by clicking the "never" option from the dropdown (for notifications and persistent-storage).
+      popupNotification = getPopupNotificationNode();
+      let secondaryActionToClickIndex = 0;
+      if (isNotificationPrompt) {
+        secondaryActionToClickIndex = 1;
+      } else {
+        popupNotification.checkbox.checked = true;
+      }
+
+      Assert.equal(
+        notification.secondaryActions.length,
+        expectedSecondaryActionsCount,
+        "There should only be " +
+          expectedSecondaryActionsCount +
+          " secondary action(s)"
+      );
+      await clickSecondaryAction(secondaryActionToClickIndex);
+      if (permissionKey) {
+        curPerm = SitePermissions.getForPrincipal(
+          principal,
+          permissionKey,
+          browser
+        );
+        Assert.equal(
+          curPerm.state,
+          SitePermissions.BLOCK,
+          "Should have denied the action"
+        );
+
+        let expectedScope = usePermissionManager
+          ? SitePermissions.SCOPE_PERSISTENT
+          : SitePermissions.SCOPE_TEMPORARY;
+        Assert.equal(
+          curPerm.scope,
+          expectedScope,
+          `Deny should be ${usePermissionManager ? "persistent" : "temporary"}`
+        );
+
+        Assert.ok(
+          mockRequest._cancelled,
+          "The request should have been cancelled"
+        );
+        Assert.ok(
+          !mockRequest._allowed,
+          "The request should not have been allowed"
+        );
+      }
+
+      SitePermissions.removeFromPrincipal(principal, permissionKey, browser);
+      mockRequest._cancelled = false;
+
+      // Bring the PopupNotification back up now...
+      shownPromise = BrowserTestUtils.waitForEvent(
+        PopupNotifications.panel,
+        "popupshown"
+      );
+      TestPrompt.prompt();
+      await shownPromise;
+
+      // Test allowing the permission request with the checkbox checked.
+      popupNotification = getPopupNotificationNode();
+      popupNotification.checkbox.checked = true;
+
+      await clickMainAction();
+      // If the prompt does not use the permission manager, it can not set a
+      // persistent allow. Temporary allow is not supported.
+      if (usePermissionManager && permissionKey) {
+        curPerm = SitePermissions.getForPrincipal(
+          principal,
+          permissionKey,
+          browser
+        );
+        Assert.equal(
+          curPerm.state,
+          SitePermissions.ALLOW,
+          "Should have allowed the action"
+        );
+        Assert.equal(
+          curPerm.scope,
+          SitePermissions.SCOPE_PERSISTENT,
+          "Allow should be permanent"
+        );
+        Assert.ok(
+          !mockRequest._cancelled,
+          "The request should not have been cancelled"
+        );
+        Assert.ok(mockRequest._allowed, "The request should have been allowed");
+      }
+    }
+  );
+}
diff --git a/browser/modules/test/browser/browser_ProcessHangNotifications.js b/browser/modules/test/browser/browser_ProcessHangNotifications.js
new file mode 100644
index 0000000000..d176f911ef
--- /dev/null
+++ b/browser/modules/test/browser/browser_ProcessHangNotifications.js
@@ -0,0 +1,484 @@
+/* globals ProcessHangMonitor */
+
+const { WebExtensionPolicy } = Cu.getGlobalForObject(Services);
+
+function promiseNotificationShown(aWindow, aName) {
+  return new Promise(resolve => {
+    let notificationBox = aWindow.gNotificationBox;
+    notificationBox.stack.addEventListener(
+      "AlertActive",
+      function () {
+        is(
+          notificationBox.allNotifications.length,
+          1,
+          "Notification Displayed."
+        );
+        resolve(notificationBox);
+      },
+      { once: true }
+    );
+  });
+}
+
+function pushPrefs(...aPrefs) {
+  return SpecialPowers.pushPrefEnv({ set: aPrefs });
+}
+
+function popPrefs() {
+  return SpecialPowers.popPrefEnv();
+}
+
+const TEST_ACTION_UNKNOWN = 0;
+const TEST_ACTION_CANCELLED = 1;
+const TEST_ACTION_TERMSCRIPT = 2;
+const TEST_ACTION_TERMGLOBAL = 3;
+const SLOW_SCRIPT = 1;
+const ADDON_HANG = 3;
+const ADDON_ID = "fake-addon";
+
+/**
+ * A mock nsIHangReport that we can pass through nsIObserverService
+ * to trigger notifications.
+ *
+ * @param hangType
+ *        One of SLOW_SCRIPT, ADDON_HANG.
+ * @param browser (optional)
+ *        The <xul:browser> that this hang should be associated with.
+ *        If not supplied, the hang will be associated with every browser,
+ *        but the nsIHangReport.scriptBrowser attribute will return the
+ *        currently selected browser in this window's gBrowser.
+ */
+let TestHangReport = function (
+  hangType = SLOW_SCRIPT,
+  browser = gBrowser.selectedBrowser
+) {
+  this.promise = new Promise((resolve, reject) => {
+    this._resolver = resolve;
+  });
+
+  if (hangType == ADDON_HANG) {
+    // Add-on hangs need an associated add-on ID for us to blame.
+    this._addonId = ADDON_ID;
+  }
+
+  this._browser = browser;
+};
+
+TestHangReport.prototype = {
+  get addonId() {
+    return this._addonId;
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIHangReport"]),
+
+  userCanceled() {
+    this._resolver(TEST_ACTION_CANCELLED);
+  },
+
+  terminateScript() {
+    this._resolver(TEST_ACTION_TERMSCRIPT);
+  },
+
+  isReportForBrowserOrChildren(aFrameLoader) {
+    if (this._browser) {
+      return this._browser.frameLoader === aFrameLoader;
+    }
+
+    return true;
+  },
+
+  get scriptBrowser() {
+    return this._browser;
+  },
+
+  // Shut up warnings about this property missing:
+  get scriptFileName() {
+    return "chrome://browser/content/browser.js";
+  },
+};
+
+// on dev edition we add a button for js debugging of hung scripts.
+let buttonCount = AppConstants.MOZ_DEV_EDITION ? 2 : 1;
+
+add_setup(async function () {
+  // Create a fake WebExtensionPolicy that we can use for
+  // the add-on hang notification.
+  const uuidGen = Services.uuid;
+  const uuid = uuidGen.generateUUID().number.slice(1, -1);
+  let policy = new WebExtensionPolicy({
+    name: "Scapegoat",
+    id: ADDON_ID,
+    mozExtensionHostname: uuid,
+    baseURL: "file:///",
+    allowedOrigins: new MatchPatternSet([]),
+    localizeCallback() {},
+  });
+  policy.active = true;
+
+  registerCleanupFunction(() => {
+    policy.active = false;
+  });
+});
+
+/**
+ * Test if hang reports receive a terminate script callback when the user selects
+ * stop in response to a script hang.
+ */
+add_task(async function terminateScriptTest() {
+  let promise = promiseNotificationShown(window, "process-hang");
+  let hangReport = new TestHangReport();
+  Services.obs.notifyObservers(hangReport, "process-hang-report");
+  let notification = await promise;
+
+  let buttons =
+    notification.currentNotification.buttonContainer.getElementsByTagName(
+      "button"
+    );
+  is(buttons.length, buttonCount, "proper number of buttons");
+
+  // Click the "Stop" button, we should get a terminate script callback
+  buttons[0].click();
+  let action = await hangReport.promise;
+  is(
+    action,
+    TEST_ACTION_TERMSCRIPT,
+    "Clicking 'Stop' should have terminated the script."
+  );
+});
+
+/**
+ * Test if hang reports receive user canceled callbacks after a user selects wait
+ * and the browser frees up from a script hang on its own.
+ */
+add_task(async function waitForScriptTest() {
+  let hangReport = new TestHangReport();
+  let promise = promiseNotificationShown(window, "process-hang");
+  Services.obs.notifyObservers(hangReport, "process-hang-report");
+  let notification = await promise;
+
+  let buttons =
+    notification.currentNotification.buttonContainer.getElementsByTagName(
+      "button"
+    );
+  is(buttons.length, buttonCount, "proper number of buttons");
+
+  await pushPrefs(["browser.hangNotification.waitPeriod", 1000]);
+
+  let ignoringReport = true;
+
+  hangReport.promise.then(action => {
+    if (ignoringReport) {
+      ok(
+        false,
+        "Hang report was somehow dealt with when it " +
+          "should have been ignored."
+      );
+    } else {
+      is(
+        action,
+        TEST_ACTION_CANCELLED,
+        "Hang report should have been cancelled."
+      );
+    }
+  });
+
+  // Click the "Close" button this time, we shouldn't get a callback at all.
+  notification.currentNotification.closeButtonEl.click();
+
+  // send another hang pulse, we should not get a notification here
+  Services.obs.notifyObservers(hangReport, "process-hang-report");
+  is(
+    notification.currentNotification,
+    null,
+    "no notification should be visible"
+  );
+
+  // Make sure that any queued Promises have run to give our report-ignoring
+  // then() a chance to fire.
+  await Promise.resolve();
+
+  ignoringReport = false;
+  Services.obs.notifyObservers(hangReport, "clear-hang-report");
+
+  await popPrefs();
+});
+
+/**
+ * Test if hang reports receive user canceled callbacks after the content
+ * process stops sending hang notifications.
+ */
+add_task(async function hangGoesAwayTest() {
+  await pushPrefs(["browser.hangNotification.expiration", 1000]);
+
+  let hangReport = new TestHangReport();
+  let promise = promiseNotificationShown(window, "process-hang");
+  Services.obs.notifyObservers(hangReport, "process-hang-report");
+  await promise;
+
+  Services.obs.notifyObservers(hangReport, "clear-hang-report");
+  let action = await hangReport.promise;
+  is(action, TEST_ACTION_CANCELLED, "Hang report should have been cancelled.");
+
+  await popPrefs();
+});
+
+/**
+ * Tests that if we're shutting down, any pre-existing hang reports will
+ * be terminated appropriately.
+ */
+add_task(async function terminateAtShutdown() {
+  let pausedHang = new TestHangReport(SLOW_SCRIPT);
+  Services.obs.notifyObservers(pausedHang, "process-hang-report");
+  ProcessHangMonitor.waitLonger(window);
+  ok(
+    ProcessHangMonitor.findPausedReport(gBrowser.selectedBrowser),
+    "There should be a paused report for the selected browser."
+  );
+
+  let scriptHang = new TestHangReport(SLOW_SCRIPT);
+  let addonHang = new TestHangReport(ADDON_HANG);
+
+  [scriptHang, addonHang].forEach(hangReport => {
+    Services.obs.notifyObservers(hangReport, "process-hang-report");
+  });
+
+  // Simulate the browser being told to shutdown. This should cause
+  // hangs to terminate scripts.
+  ProcessHangMonitor.onQuitApplicationGranted();
+
+  // In case this test happens to throw before it can finish, make
+  // sure to reset the shutting-down state.
+  registerCleanupFunction(() => {
+    ProcessHangMonitor._shuttingDown = false;
+  });
+
+  let pausedAction = await pausedHang.promise;
+  let scriptAction = await scriptHang.promise;
+  let addonAction = await addonHang.promise;
+
+  is(
+    pausedAction,
+    TEST_ACTION_TERMSCRIPT,
+    "On shutdown, should have terminated script for paused script hang."
+  );
+  is(
+    scriptAction,
+    TEST_ACTION_TERMSCRIPT,
+    "On shutdown, should have terminated script for script hang."
+  );
+  is(
+    addonAction,
+    TEST_ACTION_TERMSCRIPT,
+    "On shutdown, should have terminated script for add-on hang."
+  );
+
+  // ProcessHangMonitor should now be in the "shutting down" state,
+  // meaning that any further hangs should be handled immediately
+  // without user interaction.
+  let scriptHang2 = new TestHangReport(SLOW_SCRIPT);
+  let addonHang2 = new TestHangReport(ADDON_HANG);
+
+  [scriptHang2, addonHang2].forEach(hangReport => {
+    Services.obs.notifyObservers(hangReport, "process-hang-report");
+  });
+
+  let scriptAction2 = await scriptHang.promise;
+  let addonAction2 = await addonHang.promise;
+
+  is(
+    scriptAction2,
+    TEST_ACTION_TERMSCRIPT,
+    "On shutdown, should have terminated script for script hang."
+  );
+  is(
+    addonAction2,
+    TEST_ACTION_TERMSCRIPT,
+    "On shutdown, should have terminated script for add-on hang."
+  );
+
+  ProcessHangMonitor._shuttingDown = false;
+});
+
+/**
+ * Test that if there happens to be no open browser windows, that any
+ * hang reports that exist or appear while in this state will be handled
+ * automatically.
+ */
+add_task(async function terminateNoWindows() {
+  let testWin = await BrowserTestUtils.openNewBrowserWindow();
+
+  let pausedHang = new TestHangReport(
+    SLOW_SCRIPT,
+    testWin.gBrowser.selectedBrowser
+  );
+  Services.obs.notifyObservers(pausedHang, "process-hang-report");
+  ProcessHangMonitor.waitLonger(testWin);
+  ok(
+    ProcessHangMonitor.findPausedReport(testWin.gBrowser.selectedBrowser),
+    "There should be a paused report for the selected browser."
+  );
+
+  let scriptHang = new TestHangReport(SLOW_SCRIPT);
+  let addonHang = new TestHangReport(ADDON_HANG);
+
+  [scriptHang, addonHang].forEach(hangReport => {
+    Services.obs.notifyObservers(hangReport, "process-hang-report");
+  });
+
+  // Quick and dirty hack to trick the window mediator into thinking there
+  // are no browser windows without actually closing all browser windows.
+  document.documentElement.setAttribute(
+    "windowtype",
+    "navigator:browsertestdummy"
+  );
+
+  // In case this test happens to throw before it can finish, make
+  // sure to reset this.
+  registerCleanupFunction(() => {
+    document.documentElement.setAttribute("windowtype", "navigator:browser");
+  });
+
+  await BrowserTestUtils.closeWindow(testWin);
+
+  let pausedAction = await pausedHang.promise;
+  let scriptAction = await scriptHang.promise;
+  let addonAction = await addonHang.promise;
+
+  is(
+    pausedAction,
+    TEST_ACTION_TERMSCRIPT,
+    "With no open windows, should have terminated script for paused script hang."
+  );
+  is(
+    scriptAction,
+    TEST_ACTION_TERMSCRIPT,
+    "With no open windows, should have terminated script for script hang."
+  );
+  is(
+    addonAction,
+    TEST_ACTION_TERMSCRIPT,
+    "With no open windows, should have terminated script for add-on hang."
+  );
+
+  // ProcessHangMonitor should notice we're in the "no windows" state,
+  // so any further hangs should be handled immediately without user
+  // interaction.
+  let scriptHang2 = new TestHangReport(SLOW_SCRIPT);
+  let addonHang2 = new TestHangReport(ADDON_HANG);
+
+  [scriptHang2, addonHang2].forEach(hangReport => {
+    Services.obs.notifyObservers(hangReport, "process-hang-report");
+  });
+
+  let scriptAction2 = await scriptHang.promise;
+  let addonAction2 = await addonHang.promise;
+
+  is(
+    scriptAction2,
+    TEST_ACTION_TERMSCRIPT,
+    "With no open windows, should have terminated script for script hang."
+  );
+  is(
+    addonAction2,
+    TEST_ACTION_TERMSCRIPT,
+    "With no open windows, should have terminated script for add-on hang."
+  );
+
+  document.documentElement.setAttribute("windowtype", "navigator:browser");
+});
+
+/**
+ * Test that if a script hang occurs in one browser window, and that
+ * browser window goes away, that we clear the hang. For plug-in hangs,
+ * we do the conservative thing and terminate any plug-in hangs when a
+ * window closes, even though we don't exactly know which window it
+ * belongs to.
+ */
+add_task(async function terminateClosedWindow() {
+  let testWin = await BrowserTestUtils.openNewBrowserWindow();
+  let testBrowser = testWin.gBrowser.selectedBrowser;
+
+  let pausedHang = new TestHangReport(SLOW_SCRIPT, testBrowser);
+  Services.obs.notifyObservers(pausedHang, "process-hang-report");
+  ProcessHangMonitor.waitLonger(testWin);
+  ok(
+    ProcessHangMonitor.findPausedReport(testWin.gBrowser.selectedBrowser),
+    "There should be a paused report for the selected browser."
+  );
+
+  let scriptHang = new TestHangReport(SLOW_SCRIPT, testBrowser);
+  let addonHang = new TestHangReport(ADDON_HANG, testBrowser);
+
+  [scriptHang, addonHang].forEach(hangReport => {
+    Services.obs.notifyObservers(hangReport, "process-hang-report");
+  });
+
+  await BrowserTestUtils.closeWindow(testWin);
+
+  let pausedAction = await pausedHang.promise;
+  let scriptAction = await scriptHang.promise;
+  let addonAction = await addonHang.promise;
+
+  is(
+    pausedAction,
+    TEST_ACTION_TERMSCRIPT,
+    "When closing window, should have terminated script for a paused script hang."
+  );
+  is(
+    scriptAction,
+    TEST_ACTION_TERMSCRIPT,
+    "When closing window, should have terminated script for script hang."
+  );
+  is(
+    addonAction,
+    TEST_ACTION_TERMSCRIPT,
+    "When closing window, should have terminated script for add-on hang."
+  );
+});
+
+/**
+ * Test that permitUnload (used for closing or discarding tabs) does not
+ * try to talk to the hung child
+ */
+add_task(async function permitUnload() {
+  let testWin = await BrowserTestUtils.openNewBrowserWindow();
+  let testTab = testWin.gBrowser.selectedTab;
+
+  // Ensure we don't close the window:
+  BrowserTestUtils.addTab(testWin.gBrowser, "about:blank");
+
+  // Set up the test tab and another tab so we can check what happens when
+  // they are closed:
+  let otherTab = BrowserTestUtils.addTab(testWin.gBrowser, "about:blank");
+  let permitUnloadCount = 0;
+  for (let tab of [testTab, otherTab]) {
+    let browser = tab.linkedBrowser;
+    // Fake before unload state:
+    Object.defineProperty(browser, "hasBeforeUnload", { value: true });
+    // Increment permitUnloadCount if we ask for unload permission:
+    browser.asyncPermitUnload = () => {
+      permitUnloadCount++;
+      return Promise.resolve({ permitUnload: true });
+    };
+  }
+
+  // Set up a hang for the selected tab:
+  let testBrowser = testTab.linkedBrowser;
+  let pausedHang = new TestHangReport(SLOW_SCRIPT, testBrowser);
+  Services.obs.notifyObservers(pausedHang, "process-hang-report");
+  ProcessHangMonitor.waitLonger(testWin);
+  ok(
+    ProcessHangMonitor.findPausedReport(testWin.gBrowser.selectedBrowser),
+    "There should be a paused report for the browser we're about to remove."
+  );
+
+  BrowserTestUtils.removeTab(otherTab);
+  BrowserTestUtils.removeTab(testWin.gBrowser.getTabForBrowser(testBrowser));
+  is(
+    permitUnloadCount,
+    1,
+    "Should have called asyncPermitUnload once (not for the hung tab)."
+  );
+
+  await BrowserTestUtils.closeWindow(testWin);
+});
diff --git a/browser/modules/test/browser/browser_SitePermissions.js b/browser/modules/test/browser/browser_SitePermissions.js
new file mode 100644
index 0000000000..d8542f8f85
--- /dev/null
+++ b/browser/modules/test/browser/browser_SitePermissions.js
@@ -0,0 +1,227 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+// This tests the SitePermissions.getAllPermissionDetailsForBrowser function.
+add_task(async function testGetAllPermissionDetailsForBrowser() {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    principal.spec
+  );
+
+  Services.prefs.setIntPref("permissions.default.shortcuts", 2);
+
+  let browser = tab.linkedBrowser;
+
+  SitePermissions.setForPrincipal(principal, "camera", SitePermissions.ALLOW);
+
+  SitePermissions.setForPrincipal(
+    principal,
+    "cookie",
+    SitePermissions.ALLOW_COOKIES_FOR_SESSION
+  );
+  SitePermissions.setForPrincipal(principal, "popup", SitePermissions.BLOCK);
+  SitePermissions.setForPrincipal(
+    principal,
+    "geo",
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_SESSION
+  );
+  SitePermissions.setForPrincipal(
+    principal,
+    "shortcuts",
+    SitePermissions.ALLOW
+  );
+
+  SitePermissions.setForPrincipal(principal, "xr", SitePermissions.ALLOW);
+
+  let permissions = SitePermissions.getAllPermissionDetailsForBrowser(browser);
+
+  let camera = permissions.find(({ id }) => id === "camera");
+  Assert.deepEqual(camera, {
+    id: "camera",
+    label: "Use the camera",
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Check that removed permissions (State.UNKNOWN) are skipped.
+  SitePermissions.removeFromPrincipal(principal, "camera");
+  permissions = SitePermissions.getAllPermissionDetailsForBrowser(browser);
+
+  camera = permissions.find(({ id }) => id === "camera");
+  Assert.equal(camera, undefined);
+
+  let cookie = permissions.find(({ id }) => id === "cookie");
+  Assert.deepEqual(cookie, {
+    id: "cookie",
+    label: "Set cookies",
+    state: SitePermissions.ALLOW_COOKIES_FOR_SESSION,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  let popup = permissions.find(({ id }) => id === "popup");
+  Assert.deepEqual(popup, {
+    id: "popup",
+    label: "Open pop-up windows",
+    state: SitePermissions.BLOCK,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  let geo = permissions.find(({ id }) => id === "geo");
+  Assert.deepEqual(geo, {
+    id: "geo",
+    label: "Access your location",
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_SESSION,
+  });
+
+  let shortcuts = permissions.find(({ id }) => id === "shortcuts");
+  Assert.deepEqual(shortcuts, {
+    id: "shortcuts",
+    label: "Override keyboard shortcuts",
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  let xr = permissions.find(({ id }) => id === "xr");
+  Assert.deepEqual(xr, {
+    id: "xr",
+    label: "Access virtual reality devices",
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  SitePermissions.removeFromPrincipal(principal, "cookie");
+  SitePermissions.removeFromPrincipal(principal, "popup");
+  SitePermissions.removeFromPrincipal(principal, "geo");
+  SitePermissions.removeFromPrincipal(principal, "shortcuts");
+
+  SitePermissions.removeFromPrincipal(principal, "xr");
+
+  Services.prefs.clearUserPref("permissions.default.shortcuts");
+
+  BrowserTestUtils.removeTab(gBrowser.selectedTab);
+});
+
+add_task(async function testTemporaryChangeEvent() {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    principal.spec
+  );
+
+  let browser = tab.linkedBrowser;
+
+  let changeEventCount = 0;
+  function listener() {
+    changeEventCount++;
+  }
+
+  browser.addEventListener("PermissionStateChange", listener);
+
+  // Test browser-specific permissions.
+  SitePermissions.setForPrincipal(
+    browser.contentPrincipal,
+    "autoplay-media",
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_GLOBAL,
+    browser
+  );
+  is(changeEventCount, 1, "Should've changed");
+
+  // Setting the same value shouldn't dispatch a change event.
+  SitePermissions.setForPrincipal(
+    browser.contentPrincipal,
+    "autoplay-media",
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_GLOBAL,
+    browser
+  );
+  is(changeEventCount, 1, "Shouldn't have changed");
+
+  browser.removeEventListener("PermissionStateChange", listener);
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function testInvalidPrincipal() {
+  // Check that an error is thrown when an invalid principal argument is passed.
+  try {
+    SitePermissions.isSupportedPrincipal("file:///example.js");
+  } catch (e) {
+    Assert.equal(
+      e.message,
+      "Argument passed as principal is not an instance of Ci.nsIPrincipal"
+    );
+  }
+  try {
+    SitePermissions.removeFromPrincipal(null, "canvas");
+  } catch (e) {
+    Assert.equal(
+      e.message,
+      "Atleast one of the arguments, either principal or browser should not be null."
+    );
+  }
+  try {
+    SitePermissions.setForPrincipal(
+      "blah",
+      "camera",
+      SitePermissions.ALLOW,
+      SitePermissions.SCOPE_PERSISTENT,
+      gBrowser.selectedBrowser
+    );
+  } catch (e) {
+    Assert.equal(
+      e.message,
+      "Argument passed as principal is not an instance of Ci.nsIPrincipal"
+    );
+  }
+  try {
+    SitePermissions.getAllByPrincipal("blah");
+  } catch (e) {
+    Assert.equal(
+      e.message,
+      "Argument passed as principal is not an instance of Ci.nsIPrincipal"
+    );
+  }
+  try {
+    SitePermissions.getAllByPrincipal(null);
+  } catch (e) {
+    Assert.equal(e.message, "principal argument cannot be null.");
+  }
+  try {
+    SitePermissions.getForPrincipal(5, "camera");
+  } catch (e) {
+    Assert.equal(
+      e.message,
+      "Argument passed as principal is not an instance of Ci.nsIPrincipal"
+    );
+  }
+  // Check that no error is thrown when passing valid principal and browser arguments.
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(gBrowser.contentPrincipal, "camera"),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    }
+  );
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, "camera", gBrowser.selectedBrowser),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    }
+  );
+});
diff --git a/browser/modules/test/browser/browser_SitePermissions_combinations.js b/browser/modules/test/browser/browser_SitePermissions_combinations.js
new file mode 100644
index 0000000000..e6267f72cc
--- /dev/null
+++ b/browser/modules/test/browser/browser_SitePermissions_combinations.js
@@ -0,0 +1,144 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+// This function applies combinations of different permissions and
+// checks how they override each other.
+async function checkPermissionCombinations(combinations) {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+
+  await BrowserTestUtils.withNewTab(principal.spec, function (browser) {
+    let id = "geo";
+    for (let { reverse, states, result } of combinations) {
+      let loop = () => {
+        for (let [state, scope] of states) {
+          SitePermissions.setForPrincipal(principal, id, state, scope, browser);
+        }
+        Assert.deepEqual(
+          SitePermissions.getForPrincipal(principal, id, browser),
+          result
+        );
+        SitePermissions.removeFromPrincipal(principal, id, browser);
+      };
+
+      loop();
+
+      if (reverse) {
+        states.reverse();
+        loop();
+      }
+    }
+  });
+}
+
+// Test that passing null as scope becomes SCOPE_PERSISTENT.
+add_task(async function testDefaultScope() {
+  await checkPermissionCombinations([
+    {
+      states: [[SitePermissions.ALLOW, null]],
+      result: {
+        state: SitePermissions.ALLOW,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+  ]);
+});
+
+// Test that "wide" scopes like PERSISTENT always override "narrower" ones like TAB.
+add_task(async function testScopeOverrides() {
+  await checkPermissionCombinations([
+    {
+      // The behavior of SCOPE_SESSION is not in line with the general behavior
+      // because of the legacy nsIPermissionManager implementation.
+      states: [
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_SESSION],
+      ],
+      result: {
+        state: SitePermissions.BLOCK,
+        scope: SitePermissions.SCOPE_SESSION,
+      },
+    },
+    {
+      states: [
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_SESSION],
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+      ],
+      result: {
+        state: SitePermissions.ALLOW,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+    {
+      reverse: true,
+      states: [
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_TEMPORARY],
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_SESSION],
+      ],
+      result: {
+        state: SitePermissions.ALLOW,
+        scope: SitePermissions.SCOPE_SESSION,
+      },
+    },
+    {
+      reverse: true,
+      states: [
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_TEMPORARY],
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+      ],
+      result: {
+        state: SitePermissions.ALLOW,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+  ]);
+});
+
+// Test that clearing a temporary permission also removes a
+// persistent permission that was set for the same URL.
+add_task(async function testClearTempPermission() {
+  await checkPermissionCombinations([
+    {
+      states: [
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_TEMPORARY],
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+        [SitePermissions.UNKNOWN, SitePermissions.SCOPE_TEMPORARY],
+      ],
+      result: {
+        state: SitePermissions.UNKNOWN,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+  ]);
+});
+
+// Test that states override each other when applied with the same scope.
+add_task(async function testStateOverride() {
+  await checkPermissionCombinations([
+    {
+      states: [
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_PERSISTENT],
+      ],
+      result: {
+        state: SitePermissions.BLOCK,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+    {
+      states: [
+        [SitePermissions.BLOCK, SitePermissions.SCOPE_PERSISTENT],
+        [SitePermissions.ALLOW, SitePermissions.SCOPE_PERSISTENT],
+      ],
+      result: {
+        state: SitePermissions.ALLOW,
+        scope: SitePermissions.SCOPE_PERSISTENT,
+      },
+    },
+  ]);
+});
diff --git a/browser/modules/test/browser/browser_SitePermissions_expiry.js b/browser/modules/test/browser/browser_SitePermissions_expiry.js
new file mode 100644
index 0000000000..c5806a8008
--- /dev/null
+++ b/browser/modules/test/browser/browser_SitePermissions_expiry.js
@@ -0,0 +1,44 @@
+/* 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/. */
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+
+"use strict";
+
+const EXPIRE_TIME_MS = 100;
+const TIMEOUT_MS = 500;
+
+// This tests the time delay to expire temporary permission entries.
+add_task(async function testTemporaryPermissionExpiry() {
+  SpecialPowers.pushPrefEnv({
+    set: [["privacy.temporary_permission_expire_time_ms", EXPIRE_TIME_MS]],
+  });
+
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+  let id = "camera";
+
+  await BrowserTestUtils.withNewTab(principal.spec, async function (browser) {
+    SitePermissions.setForPrincipal(
+      principal,
+      id,
+      SitePermissions.BLOCK,
+      SitePermissions.SCOPE_TEMPORARY,
+      browser
+    );
+
+    Assert.deepEqual(SitePermissions.getForPrincipal(principal, id, browser), {
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    });
+
+    await new Promise(c => setTimeout(c, TIMEOUT_MS));
+
+    Assert.deepEqual(SitePermissions.getForPrincipal(principal, id, browser), {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    });
+  });
+});
diff --git a/browser/modules/test/browser/browser_SitePermissions_tab_urls.js b/browser/modules/test/browser/browser_SitePermissions_tab_urls.js
new file mode 100644
index 0000000000..f259486282
--- /dev/null
+++ b/browser/modules/test/browser/browser_SitePermissions_tab_urls.js
@@ -0,0 +1,128 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+function newPrincipal(origin) {
+  return Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+    origin
+  );
+}
+
+// This tests the key used to store the URI -> permission map on a tab.
+add_task(async function testTemporaryPermissionTabURLs() {
+  // Prevent showing a dialog for https://name:password@example.com
+  SpecialPowers.pushPrefEnv({
+    set: [["network.http.phishy-userpass-length", 2048]],
+  });
+
+  // This usually takes about 60 seconds on 32bit Linux debug,
+  // due to the combinatory nature of the test that is hard to fix.
+  requestLongerTimeout(2);
+
+  let same = [
+    newPrincipal("https://example.com"),
+    newPrincipal("https://example.com:443"),
+    newPrincipal("https://test1.example.com"),
+    newPrincipal("https://name:password@example.com"),
+    newPrincipal("http://example.com"),
+  ];
+  let different = [
+    newPrincipal("https://example.com"),
+    newPrincipal("http://example.org"),
+    newPrincipal("http://example.net"),
+  ];
+
+  let id = "microphone";
+
+  await BrowserTestUtils.withNewTab("about:blank", async function (browser) {
+    for (let principal of same) {
+      let loaded = BrowserTestUtils.browserLoaded(
+        browser,
+        false,
+        principal.spec
+      );
+      BrowserTestUtils.startLoadingURIString(browser, principal.spec);
+      await loaded;
+
+      SitePermissions.setForPrincipal(
+        principal,
+        id,
+        SitePermissions.BLOCK,
+        SitePermissions.SCOPE_TEMPORARY,
+        browser
+      );
+
+      for (let principal2 of same) {
+        let loaded2 = BrowserTestUtils.browserLoaded(
+          browser,
+          false,
+          principal2.URI.spec
+        );
+        BrowserTestUtils.startLoadingURIString(browser, principal2.URI.spec);
+        await loaded2;
+
+        Assert.deepEqual(
+          SitePermissions.getForPrincipal(principal2, id, browser),
+          {
+            state: SitePermissions.BLOCK,
+            scope: SitePermissions.SCOPE_TEMPORARY,
+          },
+          `${principal.spec} should share tab permissions with ${principal2.spec}`
+        );
+      }
+
+      SitePermissions.clearTemporaryBlockPermissions(browser);
+    }
+
+    for (let principal of different) {
+      let loaded = BrowserTestUtils.browserLoaded(
+        browser,
+        false,
+        principal.spec
+      );
+      BrowserTestUtils.startLoadingURIString(browser, principal.spec);
+      await loaded;
+
+      SitePermissions.setForPrincipal(
+        principal,
+        id,
+        SitePermissions.BLOCK,
+        SitePermissions.SCOPE_TEMPORARY,
+        browser
+      );
+
+      Assert.deepEqual(
+        SitePermissions.getForPrincipal(principal, id, browser),
+        {
+          state: SitePermissions.BLOCK,
+          scope: SitePermissions.SCOPE_TEMPORARY,
+        }
+      );
+
+      for (let principal2 of different) {
+        loaded = BrowserTestUtils.browserLoaded(
+          browser,
+          false,
+          principal2.URI.spec
+        );
+        BrowserTestUtils.startLoadingURIString(browser, principal2.URI.spec);
+        await loaded;
+
+        if (principal2 != principal) {
+          Assert.deepEqual(
+            SitePermissions.getForPrincipal(principal2, id, browser),
+            {
+              state: SitePermissions.UNKNOWN,
+              scope: SitePermissions.SCOPE_PERSISTENT,
+            },
+            `${principal.spec} should not share tab permissions with ${principal2.spec}`
+          );
+        }
+      }
+
+      SitePermissions.clearTemporaryBlockPermissions(browser);
+    }
+  });
+});
diff --git a/browser/modules/test/browser/browser_TabUnloader.js b/browser/modules/test/browser/browser_TabUnloader.js
new file mode 100644
index 0000000000..d564abb620
--- /dev/null
+++ b/browser/modules/test/browser/browser_TabUnloader.js
@@ -0,0 +1,381 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { TabUnloader } = ChromeUtils.importESModule(
+  "resource:///modules/TabUnloader.sys.mjs"
+);
+
+const BASE_URL = "https://example.com/browser/browser/modules/test/browser/";
+
+async function play(tab) {
+  let browser = tab.linkedBrowser;
+
+  let waitForAudioPromise = BrowserTestUtils.waitForEvent(
+    tab,
+    "TabAttrModified",
+    false,
+    event => {
+      return (
+        event.detail.changed.includes("soundplaying") &&
+        tab.hasAttribute("soundplaying")
+      );
+    }
+  );
+
+  await SpecialPowers.spawn(browser, [], async function () {
+    let audio = content.document.querySelector("audio");
+    await audio.play();
+  });
+
+  await waitForAudioPromise;
+}
+
+async function addTab(win = window) {
+  return BrowserTestUtils.openNewForegroundTab({
+    gBrowser: win.gBrowser,
+    url: BASE_URL + "dummy_page.html",
+    waitForLoad: true,
+  });
+}
+
+async function addPrivTab(win = window) {
+  const tab = BrowserTestUtils.addTab(
+    win.gBrowser,
+    BASE_URL + "dummy_page.html"
+  );
+  const browser = win.gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return tab;
+}
+
+async function addAudioTab(win = window) {
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: win.gBrowser,
+    url: BASE_URL + "file_mediaPlayback.html",
+    waitForLoad: true,
+    waitForStateStop: true,
+  });
+
+  await play(tab);
+  return tab;
+}
+
+async function addWebRTCTab(win = window) {
+  let popupPromise = new Promise(resolve => {
+    win.PopupNotifications.panel.addEventListener(
+      "popupshown",
+      function () {
+        executeSoon(resolve);
+      },
+      { once: true }
+    );
+  });
+
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: win.gBrowser,
+    url: BASE_URL + "file_webrtc.html",
+    waitForLoad: true,
+    waitForStateStop: true,
+  });
+
+  await popupPromise;
+
+  let recordingPromise = BrowserTestUtils.contentTopicObserved(
+    tab.linkedBrowser.browsingContext,
+    "recording-device-events"
+  );
+  win.PopupNotifications.panel.firstElementChild.button.click();
+  await recordingPromise;
+
+  return tab;
+}
+
+async function pressure() {
+  let tabDiscarded = BrowserTestUtils.waitForEvent(
+    document,
+    "TabBrowserDiscarded",
+    true
+  );
+  TabUnloader.unloadTabAsync(null);
+  return tabDiscarded;
+}
+
+function pressureAndObserve(aExpectedTopic) {
+  const promise = new Promise(resolve => {
+    const observer = {
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIObserver",
+        "nsISupportsWeakReference",
+      ]),
+      observe(aSubject, aTopicInner, aData) {
+        if (aTopicInner == aExpectedTopic) {
+          Services.obs.removeObserver(observer, aTopicInner);
+          resolve(aData);
+        }
+      },
+    };
+    Services.obs.addObserver(observer, aExpectedTopic);
+  });
+  TabUnloader.unloadTabAsync(null);
+  return promise;
+}
+
+async function compareTabOrder(expectedOrder) {
+  let tabInfo = await TabUnloader.getSortedTabs(null);
+
+  is(
+    tabInfo.length,
+    expectedOrder.length,
+    "right number of tabs in discard sort list"
+  );
+  for (let idx = 0; idx < expectedOrder.length; idx++) {
+    is(tabInfo[idx].tab, expectedOrder[idx], "index " + idx + " is correct");
+  }
+}
+
+const PREF_PERMISSION_FAKE = "media.navigator.permission.fake";
+const PREF_AUDIO_LOOPBACK = "media.audio_loopback_dev";
+const PREF_VIDEO_LOOPBACK = "media.video_loopback_dev";
+const PREF_FAKE_STREAMS = "media.navigator.streams.fake";
+const PREF_ENABLE_UNLOADER = "browser.tabs.unloadOnLowMemory";
+const PREF_MAC_LOW_MEM_RESPONSE = "browser.lowMemoryResponseMask";
+
+add_task(async function test() {
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref(PREF_ENABLE_UNLOADER);
+    if (AppConstants.platform == "macosx") {
+      Services.prefs.clearUserPref(PREF_MAC_LOW_MEM_RESPONSE);
+    }
+  });
+  Services.prefs.setBoolPref(PREF_ENABLE_UNLOADER, true);
+
+  // On Mac, tab unloading and memory pressure notifications are limited
+  // to Nightly so force them on for this test for non-Nightly builds. i.e.,
+  // tests on Release and Beta builds. Mac tab unloading and memory pressure
+  // notifications require this pref to be set.
+  if (AppConstants.platform == "macosx") {
+    Services.prefs.setIntPref(PREF_MAC_LOW_MEM_RESPONSE, 3);
+  }
+
+  TabUnloader.init();
+
+  // Set some WebRTC simulation preferences.
+  let prefs = [
+    [PREF_PERMISSION_FAKE, true],
+    [PREF_AUDIO_LOOPBACK, ""],
+    [PREF_VIDEO_LOOPBACK, ""],
+    [PREF_FAKE_STREAMS, true],
+  ];
+  await SpecialPowers.pushPrefEnv({ set: prefs });
+
+  // Set up 6 tabs, three normal ones, one pinned, one playing sound and one
+  // pinned playing sound
+  let tab0 = gBrowser.tabs[0];
+  let tab1 = await addTab();
+  let tab2 = await addTab();
+  let pinnedTab = await addTab();
+  gBrowser.pinTab(pinnedTab);
+  let soundTab = await addAudioTab();
+  let pinnedSoundTab = await addAudioTab();
+  gBrowser.pinTab(pinnedSoundTab);
+
+  // Open a new private window and add a tab
+  const windowPriv = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  const tabPriv0 = windowPriv.gBrowser.tabs[0];
+  const tabPriv1 = await addPrivTab(windowPriv);
+
+  // Move the original window to the foreground to pass the tests
+  gBrowser.selectedTab = tab0;
+  tab0.ownerGlobal.focus();
+
+  // Pretend we've visited the tabs
+  await BrowserTestUtils.switchTab(windowPriv.gBrowser, tabPriv1);
+  await BrowserTestUtils.switchTab(windowPriv.gBrowser, tabPriv0);
+  await BrowserTestUtils.switchTab(gBrowser, tab1);
+  await BrowserTestUtils.switchTab(gBrowser, tab2);
+  await BrowserTestUtils.switchTab(gBrowser, pinnedTab);
+  await BrowserTestUtils.switchTab(gBrowser, soundTab);
+  await BrowserTestUtils.switchTab(gBrowser, pinnedSoundTab);
+  await BrowserTestUtils.switchTab(gBrowser, tab0);
+
+  // Checks the tabs are in the state we expect them to be
+  ok(pinnedTab.pinned, "tab is pinned");
+  ok(pinnedSoundTab.soundPlaying, "tab is playing sound");
+  ok(
+    pinnedSoundTab.pinned && pinnedSoundTab.soundPlaying,
+    "tab is pinned and playing sound"
+  );
+
+  await compareTabOrder([
+    tab1,
+    tab2,
+    pinnedTab,
+    tabPriv1,
+    soundTab,
+    tab0,
+    pinnedSoundTab,
+    tabPriv0,
+  ]);
+
+  // Check that the tabs are present
+  ok(
+    tab1.linkedPanel &&
+      tab2.linkedPanel &&
+      pinnedTab.linkedPanel &&
+      soundTab.linkedPanel &&
+      pinnedSoundTab.linkedPanel &&
+      tabPriv0.linkedPanel &&
+      tabPriv1.linkedPanel,
+    "tabs are present"
+  );
+
+  // Check that low-memory memory-pressure events unload tabs
+  await pressure();
+  ok(
+    !tab1.linkedPanel,
+    "low-memory memory-pressure notification unloaded the LRU tab"
+  );
+
+  await compareTabOrder([
+    tab2,
+    pinnedTab,
+    tabPriv1,
+    soundTab,
+    tab0,
+    pinnedSoundTab,
+    tabPriv0,
+  ]);
+
+  // If no normal tab is available unload pinned tabs
+  await pressure();
+  ok(!tab2.linkedPanel, "unloaded a second tab in LRU order");
+  await compareTabOrder([
+    pinnedTab,
+    tabPriv1,
+    soundTab,
+    tab0,
+    pinnedSoundTab,
+    tabPriv0,
+  ]);
+
+  ok(soundTab.soundPlaying, "tab is still playing sound");
+
+  await pressure();
+  ok(!pinnedTab.linkedPanel, "unloaded a pinned tab");
+  await compareTabOrder([tabPriv1, soundTab, tab0, pinnedSoundTab, tabPriv0]);
+
+  ok(pinnedSoundTab.soundPlaying, "tab is still playing sound");
+
+  // There are no unloadable tabs.
+  TabUnloader.unloadTabAsync(null);
+  ok(tabPriv1.linkedPanel, "a tab in a private window is never unloaded");
+
+  const histogram = TelemetryTestUtils.getAndClearHistogram(
+    "TAB_UNLOAD_TO_RELOAD"
+  );
+
+  // It's possible that we're already in the memory-pressure state
+  // and we may receive the "ongoing" message.
+  const message = await pressureAndObserve("memory-pressure");
+  Assert.ok(
+    message == "low-memory" || message == "low-memory-ongoing",
+    "observed the memory-pressure notification because of no discardable tab"
+  );
+
+  // Add a WebRTC tab and another sound tab.
+  let webrtcTab = await addWebRTCTab();
+  let anotherSoundTab = await addAudioTab();
+
+  await BrowserTestUtils.switchTab(gBrowser, tab1);
+  await BrowserTestUtils.switchTab(gBrowser, pinnedTab);
+
+  const hist = histogram.snapshot();
+  const numEvents = Object.values(hist.values).reduce((a, b) => a + b);
+  Assert.equal(numEvents, 2, "two tabs have been reloaded.");
+
+  // tab0 has never been unloaded.  No data is added to the histogram.
+  await BrowserTestUtils.switchTab(gBrowser, tab0);
+
+  await compareTabOrder([
+    tab1,
+    pinnedTab,
+    tabPriv1,
+    soundTab,
+    webrtcTab,
+    anotherSoundTab,
+    tab0,
+    pinnedSoundTab,
+    tabPriv0,
+  ]);
+
+  await BrowserTestUtils.closeWindow(windowPriv);
+
+  let window2 = await BrowserTestUtils.openNewBrowserWindow();
+  let win2tab1 = window2.gBrowser.selectedTab;
+  let win2tab2 = await addTab(window2);
+  let win2winrtcTab = await addWebRTCTab(window2);
+  let win2tab3 = await addTab(window2);
+
+  await compareTabOrder([
+    tab1,
+    win2tab1,
+    win2tab2,
+    pinnedTab,
+    soundTab,
+    webrtcTab,
+    anotherSoundTab,
+    win2winrtcTab,
+    tab0,
+    win2tab3,
+    pinnedSoundTab,
+  ]);
+
+  await BrowserTestUtils.closeWindow(window2);
+
+  await compareTabOrder([
+    tab1,
+    pinnedTab,
+    soundTab,
+    webrtcTab,
+    anotherSoundTab,
+    tab0,
+    pinnedSoundTab,
+  ]);
+
+  // Cleanup
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(pinnedTab);
+  BrowserTestUtils.removeTab(soundTab);
+  BrowserTestUtils.removeTab(pinnedSoundTab);
+  BrowserTestUtils.removeTab(webrtcTab);
+  BrowserTestUtils.removeTab(anotherSoundTab);
+
+  await awaitWebRTCClose();
+});
+
+// Wait for the WebRTC indicator window to close.
+function awaitWebRTCClose() {
+  if (
+    Services.prefs.getBoolPref("privacy.webrtc.legacyGlobalIndicator", false) ||
+    AppConstants.platform == "macosx"
+  ) {
+    return null;
+  }
+
+  let win = Services.wm.getMostRecentWindow("Browser:WebRTCGlobalIndicator");
+  if (!win) {
+    return null;
+  }
+
+  return new Promise(resolve => {
+    win.addEventListener("unload", function listener(e) {
+      if (e.target == win.document) {
+        win.removeEventListener("unload", listener);
+        executeSoon(resolve);
+      }
+    });
+  });
+}
diff --git a/browser/modules/test/browser/browser_Telemetry_numberOfSiteOrigins.js b/browser/modules/test/browser/browser_Telemetry_numberOfSiteOrigins.js
new file mode 100644
index 0000000000..9ce5602eda
--- /dev/null
+++ b/browser/modules/test/browser/browser_Telemetry_numberOfSiteOrigins.js
@@ -0,0 +1,53 @@
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+/**
+ * This file tests page reload key combination telemetry
+ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+});
+
+const gTestRoot = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "http://mochi.test:8888"
+);
+
+const { TimedPromise } = ChromeUtils.importESModule(
+  "chrome://remote/content/marionette/sync.sys.mjs"
+);
+
+async function run_test(count) {
+  const histogram = TelemetryTestUtils.getAndClearHistogram(
+    "FX_NUMBER_OF_UNIQUE_SITE_ORIGINS_ALL_TABS"
+  );
+
+  let newTab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: gTestRoot + "contain_iframe.html",
+    waitForStateStop: true,
+  });
+
+  await new Promise(resolve =>
+    setTimeout(function () {
+      window.requestIdleCallback(resolve);
+    }, 1000)
+  );
+
+  if (count < 2) {
+    await BrowserTestUtils.removeTab(newTab);
+    await run_test(count + 1);
+  } else {
+    TelemetryTestUtils.assertHistogram(histogram, 2, 1);
+    await BrowserTestUtils.removeTab(newTab);
+  }
+}
+
+add_task(async function test_telemetryMoreSiteOrigin() {
+  await run_test(1);
+});
diff --git a/browser/modules/test/browser/browser_Telemetry_numberOfSiteOriginsPerDocument.js b/browser/modules/test/browser/browser_Telemetry_numberOfSiteOriginsPerDocument.js
new file mode 100644
index 0000000000..d60660960f
--- /dev/null
+++ b/browser/modules/test/browser/browser_Telemetry_numberOfSiteOriginsPerDocument.js
@@ -0,0 +1,134 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+});
+
+const histogramName = "FX_NUMBER_OF_UNIQUE_SITE_ORIGINS_PER_DOCUMENT";
+const testRoot = getRootDirectory(gTestPath).replace(
+  "chrome://mochitests/content",
+  "http://mochi.test:8888"
+);
+
+function windowGlobalDestroyed(id) {
+  return BrowserUtils.promiseObserved(
+    "window-global-destroyed",
+    aWGP => aWGP.innerWindowId == id
+  );
+}
+
+async function openAndCloseTab(uri) {
+  const tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: uri,
+  });
+
+  const innerWindowId =
+    tab.linkedBrowser.browsingContext.currentWindowGlobal.innerWindowId;
+
+  const wgpDestroyed = windowGlobalDestroyed(innerWindowId);
+  BrowserTestUtils.removeTab(tab);
+  await wgpDestroyed;
+}
+
+add_task(async function test_numberOfSiteOriginsAfterTabClose() {
+  const histogram = TelemetryTestUtils.getAndClearHistogram(histogramName);
+  const testPage = `${testRoot}contain_iframe.html`;
+
+  await openAndCloseTab(testPage);
+
+  // testPage contains two origins: mochi.test:8888 and example.com.
+  TelemetryTestUtils.assertHistogram(histogram, 2, 1);
+});
+
+add_task(async function test_numberOfSiteOriginsAboutBlank() {
+  const histogram = TelemetryTestUtils.getAndClearHistogram(histogramName);
+
+  await openAndCloseTab("about:blank");
+
+  const { values } = histogram.snapshot();
+  Assert.deepEqual(
+    values,
+    {},
+    `Histogram should have no values; had ${JSON.stringify(values)}`
+  );
+});
+
+add_task(async function test_numberOfSiteOriginsMultipleNavigations() {
+  const histogram = TelemetryTestUtils.getAndClearHistogram(histogramName);
+  const testPage = `${testRoot}contain_iframe.html`;
+
+  const tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: testPage,
+    waitForStateStop: true,
+  });
+
+  const wgpDestroyedPromises = [
+    windowGlobalDestroyed(tab.linkedBrowser.innerWindowID),
+  ];
+
+  // Navigate to an interstitial page.
+  BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, "about:blank");
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  // Navigate to another test page.
+  BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, testPage);
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  wgpDestroyedPromises.push(
+    windowGlobalDestroyed(tab.linkedBrowser.innerWindowID)
+  );
+
+  BrowserTestUtils.removeTab(tab);
+  await Promise.all(wgpDestroyedPromises);
+
+  // testPage has been loaded twice and contains two origins: mochi.test:8888
+  // and example.com.
+  TelemetryTestUtils.assertHistogram(histogram, 2, 2);
+});
+
+add_task(async function test_numberOfSiteOriginsAddAndRemove() {
+  const histogram = TelemetryTestUtils.getAndClearHistogram(histogramName);
+  const testPage = `${testRoot}blank_iframe.html`;
+
+  const tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: testPage,
+    waitForStateStop: true,
+  });
+
+  // Load a subdocument in the page's iframe.
+  await SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    const iframe = content.window.document.querySelector("iframe");
+    const loaded = new Promise(resolve => {
+      iframe.addEventListener("load", () => resolve(), { once: true });
+    });
+    iframe.src = "http://example.com";
+
+    await loaded;
+  });
+
+  // Load a *new* subdocument in the page's iframe. This will result in the page
+  // having had three different origins, but only two at any one time.
+  await SpecialPowers.spawn(tab.linkedBrowser, [], async () => {
+    const iframe = content.window.document.querySelector("iframe");
+    const loaded = new Promise(resolve => {
+      iframe.addEventListener("load", () => resolve(), { once: true });
+    });
+    iframe.src = "http://example.org";
+
+    await loaded;
+  });
+
+  const wgpDestroyed = windowGlobalDestroyed(tab.linkedBrowser.innerWindowID);
+  BrowserTestUtils.removeTab(tab);
+  await wgpDestroyed;
+
+  // The page only ever had two origins at once.
+  TelemetryTestUtils.assertHistogram(histogram, 2, 1);
+});
diff --git a/browser/modules/test/browser/browser_UnsubmittedCrashHandler.js b/browser/modules/test/browser/browser_UnsubmittedCrashHandler.js
new file mode 100644
index 0000000000..4305d7f7df
--- /dev/null
+++ b/browser/modules/test/browser/browser_UnsubmittedCrashHandler.js
@@ -0,0 +1,815 @@
+"use strict";
+
+/**
+ * This suite tests the "unsubmitted crash report" notification
+ * that is seen when we detect pending crash reports on startup.
+ */
+
+const { UnsubmittedCrashHandler } = ChromeUtils.importESModule(
+  "resource:///modules/ContentCrashHandlers.sys.mjs"
+);
+
+const { makeFakeAppDir } = ChromeUtils.importESModule(
+  "resource://testing-common/AppData.sys.mjs"
+);
+
+const DAY = 24 * 60 * 60 * 1000; // milliseconds
+const SERVER_URL =
+  "http://example.com/browser/toolkit/crashreporter/test/browser/crashreport.sjs";
+
+/**
+ * Returns the directly where the browsing is storing the
+ * pending crash reports.
+ *
+ * @returns nsIFile
+ */
+function getPendingCrashReportDir() {
+  // The fake UAppData directory that makeFakeAppDir provides
+  // is just UAppData under the profile directory.
+  return FileUtils.getDir("ProfD", ["UAppData", "Crash Reports", "pending"]);
+}
+
+/**
+ * Synchronously deletes all entries inside the pending
+ * crash report directory.
+ */
+function clearPendingCrashReports() {
+  let dir = getPendingCrashReportDir();
+  let entries = dir.directoryEntries;
+
+  while (entries.hasMoreElements()) {
+    let entry = entries.nextFile;
+    if (entry.isFile()) {
+      entry.remove(false);
+    }
+  }
+}
+
+/**
+ * Randomly generates howMany crash report .dmp and .extra files
+ * to put into the pending crash report directory. We're not
+ * actually creating real crash reports here, just stubbing
+ * out enough of the files to satisfy our notification and
+ * submission code.
+ *
+ * @param howMany (int)
+ *        How many pending crash reports to put in the pending
+ *        crash report directory.
+ * @param accessDate (Date, optional)
+ *        What date to set as the last accessed time on the created
+ *        crash reports. This defaults to the current date and time.
+ * @returns Promise
+ */
+function createPendingCrashReports(howMany, accessDate) {
+  let dir = getPendingCrashReportDir();
+  if (!accessDate) {
+    accessDate = new Date();
+  }
+
+  /**
+   * Helper function for creating a file in the pending crash report
+   * directory.
+   *
+   * @param fileName (string)
+   *        The filename for the crash report, not including the
+   *        extension. This is usually a UUID.
+   * @param extension (string)
+   *        The file extension for the created file.
+   * @param accessDate (Date, optional)
+   *        The date to set lastAccessed to, if anything.
+   * @param contents (string, optional)
+   *        Set this to whatever the file needs to contain, if anything.
+   * @returns Promise
+   */
+  let createFile = async (fileName, extension, lastAccessedDate, contents) => {
+    let file = dir.clone();
+    file.append(fileName + "." + extension);
+    file.create(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
+
+    if (contents) {
+      await IOUtils.writeUTF8(file.path, contents, {
+        tmpPath: file.path + ".tmp",
+      });
+    }
+
+    if (lastAccessedDate) {
+      await IOUtils.setAccessTime(file.path, lastAccessedDate.valueOf());
+    }
+  };
+
+  let uuidGenerator = Services.uuid;
+  // Some annotations are always present in the .extra file and CrashSubmit.jsm
+  // expects there to be a ServerURL entry, so we'll add them here.
+  let extraFileContents = JSON.stringify({
+    ServerURL: SERVER_URL,
+    TelemetryServerURL: "http://telemetry.mozilla.org/",
+    TelemetryClientId: "c69e7487-df10-4c98-ab1a-c85660feecf3",
+    TelemetrySessionId: "22af5a41-6e84-4112-b1f7-4cb12cb6f6a5",
+  });
+
+  return (async function () {
+    let uuids = [];
+    for (let i = 0; i < howMany; ++i) {
+      let uuid = uuidGenerator.generateUUID().toString();
+      // Strip the {}...
+      uuid = uuid.substring(1, uuid.length - 1);
+      await createFile(uuid, "dmp", accessDate);
+      await createFile(uuid, "extra", accessDate, extraFileContents);
+      uuids.push(uuid);
+    }
+    return uuids;
+  })();
+}
+
+/**
+ * Returns a Promise that resolves once CrashSubmit starts sending
+ * success notifications for crash submission matching the reportIDs
+ * being passed in.
+ *
+ * @param reportIDs (Array<string>)
+ *        The IDs for the reports that we expect CrashSubmit to have sent.
+ * @param extraCheck (Function, optional)
+ *        A function that receives the annotations of the crash report and can
+ *        be used for checking them
+ * @returns Promise
+ */
+function waitForSubmittedReports(reportIDs, extraCheck) {
+  let promises = [];
+  for (let reportID of reportIDs) {
+    let promise = TestUtils.topicObserved(
+      "crash-report-status",
+      (subject, data) => {
+        if (data == "success") {
+          let propBag = subject.QueryInterface(Ci.nsIPropertyBag2);
+          let dumpID = propBag.getPropertyAsAString("minidumpID");
+          if (dumpID == reportID) {
+            if (extraCheck) {
+              let extra = propBag.getPropertyAsInterface(
+                "extra",
+                Ci.nsIPropertyBag2
+              );
+
+              extraCheck(extra);
+            }
+
+            return true;
+          }
+        }
+        return false;
+      }
+    );
+    promises.push(promise);
+  }
+  return Promise.all(promises);
+}
+
+/**
+ * Returns a Promise that resolves once a .dmp.ignore file is created for
+ * the crashes in the pending directory matching the reportIDs being
+ * passed in.
+ *
+ * @param reportIDs (Array<string>)
+ *        The IDs for the reports that we expect CrashSubmit to have been
+ *        marked for ignoring.
+ * @returns Promise
+ */
+function waitForIgnoredReports(reportIDs) {
+  let dir = getPendingCrashReportDir();
+  let promises = [];
+  for (let reportID of reportIDs) {
+    let file = dir.clone();
+    file.append(reportID + ".dmp.ignore");
+    promises.push(IOUtils.exists(file.path));
+  }
+  return Promise.all(promises);
+}
+
+add_setup(async function () {
+  // Pending crash reports are stored in the UAppData folder,
+  // which exists outside of the profile folder. In order to
+  // not overwrite / clear pending crash reports for the poor
+  // soul who runs this test, we use AppData.sys.mjs to point to
+  // a special made-up directory inside the profile
+  // directory.
+  await makeFakeAppDir();
+  // We'll assume that the notifications will be shown in the current
+  // browser window's global notification box.
+
+  // If we happen to already be seeing the unsent crash report
+  // notification, it's because the developer running this test
+  // happened to have some unsent reports in their UAppDir.
+  // We'll remove the notification without touching those reports.
+  let notification = gNotificationBox.getNotificationWithValue(
+    "pending-crash-reports"
+  );
+  if (notification) {
+    notification.close();
+  }
+
+  let oldServerURL = Services.env.get("MOZ_CRASHREPORTER_URL");
+  Services.env.set("MOZ_CRASHREPORTER_URL", SERVER_URL);
+
+  // nsBrowserGlue starts up UnsubmittedCrashHandler automatically
+  // on a timer, so at this point, it can be in one of several states:
+  //
+  // 1. The timer hasn't yet finished, and an automatic scan for crash
+  //    reports is pending.
+  // 2. The timer has already gone off and the scan has already completed.
+  // 3. The handler is disabled.
+  //
+  // To collapse all of these possibilities, we uninit the UnsubmittedCrashHandler
+  // to cancel the timer, make sure it's preffed on, and then restart it (which
+  // doesn't restart the timer). Note that making the component initialize
+  // even when it's disabled is an intentional choice, as this allows for easier
+  // simulation of startup and shutdown.
+  UnsubmittedCrashHandler.uninit();
+
+  // While we're here, let's test that we don't show the notification
+  // if we're disabled and something happens to check for unsubmitted
+  // crash reports.
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.crashReports.unsubmittedCheck.enabled", false]],
+  });
+
+  await createPendingCrashReports(1);
+
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(!notification, "There should not be a notification");
+
+  clearPendingCrashReports();
+  await SpecialPowers.popPrefEnv();
+
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.crashReports.unsubmittedCheck.enabled", true]],
+  });
+  UnsubmittedCrashHandler.init();
+
+  registerCleanupFunction(function () {
+    clearPendingCrashReports();
+    Services.env.set("MOZ_CRASHREPORTER_URL", oldServerURL);
+  });
+});
+
+/**
+ * Tests that if there are no pending crash reports, then the
+ * notification will not show up.
+ */
+add_task(async function test_no_pending_no_notification() {
+  // Make absolutely sure there are no pending crash reports first...
+  clearPendingCrashReports();
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.equal(
+    notification,
+    null,
+    "There should not be a notification if there are no " +
+      "pending crash reports"
+  );
+});
+
+/**
+ * Tests that there is a notification if there is one pending
+ * crash report.
+ */
+add_task(async function test_one_pending() {
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that an ignored crash report does not suppress a notification that
+ * would be trigged by another, unignored crash report.
+ */
+add_task(async function test_other_ignored() {
+  let toIgnore = await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Dismiss notification, creating the .dmp.ignore file
+  notification.closeButtonEl.click();
+  gNotificationBox.removeNotification(notification, true);
+  await waitForIgnoredReports(toIgnore);
+
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(!notification, "There should not be a notification");
+
+  await createPendingCrashReports(1);
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that there is a notification if there is more than one
+ * pending crash report.
+ */
+add_task(async function test_several_pending() {
+  await createPendingCrashReports(3);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that there is no notification if the only pending crash
+ * reports are over 28 days old. Also checks that if we put a newer
+ * crash with that older set, that we can still get a notification.
+ */
+add_task(async function test_several_pending() {
+  // Let's create some crash reports from 30 days ago.
+  let oldDate = new Date(Date.now() - 30 * DAY);
+  await createPendingCrashReports(3, oldDate);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.equal(
+    notification,
+    null,
+    "There should not be a notification if there are only " +
+      "old pending crash reports"
+  );
+  // Now let's create a new one and check again
+  await createPendingCrashReports(1);
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that the notification can submit a report.
+ */
+add_task(async function test_can_submit() {
+  function extraCheck(extra) {
+    const blockedAnnotations = [
+      "ServerURL",
+      "TelemetryClientId",
+      "TelemetryServerURL",
+      "TelemetrySessionId",
+    ];
+    for (const key of blockedAnnotations) {
+      Assert.ok(
+        !extra.hasKey(key),
+        "The " + key + " annotation should have been stripped away"
+      );
+    }
+
+    Assert.equal(extra.get("SubmittedFrom"), "Infobar");
+    Assert.equal(extra.get("Throttleable"), "1");
+  }
+
+  let reportIDs = await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Attempt to submit the notification by clicking on the submit
+  // button
+  let buttons = notification.buttonContainer.querySelectorAll(
+    ".notification-button"
+  );
+  // ...which should be the first button.
+  let submit = buttons[0];
+  let promiseReports = waitForSubmittedReports(reportIDs, extraCheck);
+  info("Sending crash report");
+  submit.click();
+  info("Sent!");
+  // We'll not wait for the notification to finish its transition -
+  // we'll just remove it right away.
+  gNotificationBox.removeNotification(notification, true);
+
+  info("Waiting on reports to be received.");
+  await promiseReports;
+  info("Received!");
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that the notification can submit multiple reports.
+ */
+add_task(async function test_can_submit_several() {
+  let reportIDs = await createPendingCrashReports(3);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Attempt to submit the notification by clicking on the submit
+  // button
+  let buttons = notification.buttonContainer.querySelectorAll(
+    ".notification-button"
+  );
+  // ...which should be the first button.
+  let submit = buttons[0];
+
+  let promiseReports = waitForSubmittedReports(reportIDs);
+  info("Sending crash reports");
+  submit.click();
+  info("Sent!");
+  // We'll not wait for the notification to finish its transition -
+  // we'll just remove it right away.
+  gNotificationBox.removeNotification(notification, true);
+
+  info("Waiting on reports to be received.");
+  await promiseReports;
+  info("Received!");
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that choosing "Send Always" flips the autoSubmit pref
+ * and sends the pending crash reports.
+ */
+add_task(async function test_can_submit_always() {
+  let pref = "browser.crashReports.unsubmittedCheck.autoSubmit2";
+  Assert.equal(
+    Services.prefs.getBoolPref(pref),
+    false,
+    "We should not be auto-submitting by default"
+  );
+
+  let reportIDs = await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Attempt to submit the notification by clicking on the send all
+  // button
+  let buttons = notification.buttonContainer.querySelectorAll(
+    ".notification-button"
+  );
+  // ...which should be the second button.
+  let sendAll = buttons[1];
+
+  let promiseReports = waitForSubmittedReports(reportIDs);
+  info("Sending crash reports");
+  sendAll.click();
+  info("Sent!");
+  // We'll not wait for the notification to finish its transition -
+  // we'll just remove it right away.
+  gNotificationBox.removeNotification(notification, true);
+
+  info("Waiting on reports to be received.");
+  await promiseReports;
+  info("Received!");
+
+  // Make sure the pref was set
+  Assert.equal(
+    Services.prefs.getBoolPref(pref),
+    true,
+    "The autoSubmit pref should have been set"
+  );
+
+  // Create another report
+  reportIDs = await createPendingCrashReports(1);
+  let result = await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+
+  // Check that the crash was auto-submitted
+  Assert.equal(result, null, "The notification should not be shown");
+  promiseReports = await waitForSubmittedReports(reportIDs, extra => {
+    Assert.equal(extra.get("SubmittedFrom"), "Auto");
+    Assert.equal(extra.get("Throttleable"), "1");
+  });
+
+  // And revert back to default now.
+  Services.prefs.clearUserPref(pref);
+
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if the user has chosen to automatically send
+ * crash reports that no notification is displayed to the
+ * user.
+ */
+add_task(async function test_can_auto_submit() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.crashReports.unsubmittedCheck.autoSubmit2", true]],
+  });
+
+  let reportIDs = await createPendingCrashReports(3);
+  let promiseReports = waitForSubmittedReports(reportIDs);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.equal(notification, null, "There should be no notification");
+  info("Waiting on reports to be received.");
+  await promiseReports;
+  info("Received!");
+
+  clearPendingCrashReports();
+  await SpecialPowers.popPrefEnv();
+});
+
+/**
+ * Tests that if the user chooses to dismiss the notification,
+ * then the current pending requests won't cause the notification
+ * to appear again in the future.
+ */
+add_task(async function test_can_ignore() {
+  let reportIDs = await createPendingCrashReports(3);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Dismiss the notification by clicking on the "X" button.
+  notification.closeButtonEl.click();
+  // We'll not wait for the notification to finish its transition -
+  // we'll just remove it right away.
+  gNotificationBox.removeNotification(notification, true);
+  await waitForIgnoredReports(reportIDs);
+
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.equal(notification, null, "There should be no notification");
+
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if the notification is shown, then the
+ * lastShownDate is set for today.
+ */
+add_task(async function test_last_shown_date() {
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  let today = UnsubmittedCrashHandler.dateString(new Date());
+  let lastShownDate =
+    UnsubmittedCrashHandler.prefs.getCharPref("lastShownDate");
+  Assert.equal(today, lastShownDate, "Last shown date should be today.");
+
+  UnsubmittedCrashHandler.prefs.clearUserPref("lastShownDate");
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if UnsubmittedCrashHandler is uninit with a
+ * notification still being shown, that
+ * browser.crashReports.unsubmittedCheck.shutdownWhileShowing is
+ * set to true.
+ */
+add_task(async function test_shutdown_while_showing() {
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  UnsubmittedCrashHandler.uninit();
+  let shutdownWhileShowing = UnsubmittedCrashHandler.prefs.getBoolPref(
+    "shutdownWhileShowing"
+  );
+  Assert.ok(
+    shutdownWhileShowing,
+    "We should have noticed that we uninitted while showing " +
+      "the notification."
+  );
+  UnsubmittedCrashHandler.prefs.clearUserPref("shutdownWhileShowing");
+  UnsubmittedCrashHandler.init();
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if UnsubmittedCrashHandler is uninit after
+ * the notification has been closed, that
+ * browser.crashReports.unsubmittedCheck.shutdownWhileShowing is
+ * not set in prefs.
+ */
+add_task(async function test_shutdown_while_not_showing() {
+  let reportIDs = await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  // Dismiss the notification by clicking on the "X" button.
+  notification.closeButtonEl.click();
+  // We'll not wait for the notification to finish its transition -
+  // we'll just remove it right away.
+  gNotificationBox.removeNotification(notification, true);
+
+  await waitForIgnoredReports(reportIDs);
+
+  UnsubmittedCrashHandler.uninit();
+  Assert.throws(
+    () => {
+      UnsubmittedCrashHandler.prefs.getBoolPref("shutdownWhileShowing");
+    },
+    /NS_ERROR_UNEXPECTED/,
+    "We should have noticed that the notification had closed before uninitting."
+  );
+  UnsubmittedCrashHandler.init();
+
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if
+ * browser.crashReports.unsubmittedCheck.shutdownWhileShowing is
+ * set and the lastShownDate is today, then we don't decrement
+ * browser.crashReports.unsubmittedCheck.chancesUntilSuppress.
+ */
+add_task(async function test_dont_decrement_chances_on_same_day() {
+  let initChances = UnsubmittedCrashHandler.prefs.getIntPref(
+    "chancesUntilSuppress"
+  );
+  Assert.greater(initChances, 1, "We should start with at least 1 chance.");
+
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  UnsubmittedCrashHandler.uninit();
+
+  gNotificationBox.removeNotification(notification, true);
+
+  let shutdownWhileShowing = UnsubmittedCrashHandler.prefs.getBoolPref(
+    "shutdownWhileShowing"
+  );
+  Assert.ok(
+    shutdownWhileShowing,
+    "We should have noticed that we uninitted while showing " +
+      "the notification."
+  );
+
+  let today = UnsubmittedCrashHandler.dateString(new Date());
+  let lastShownDate =
+    UnsubmittedCrashHandler.prefs.getCharPref("lastShownDate");
+  Assert.equal(today, lastShownDate, "Last shown date should be today.");
+
+  UnsubmittedCrashHandler.init();
+
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should still be a notification");
+
+  let chances = UnsubmittedCrashHandler.prefs.getIntPref(
+    "chancesUntilSuppress"
+  );
+
+  Assert.equal(initChances, chances, "We should not have decremented chances.");
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if
+ * browser.crashReports.unsubmittedCheck.shutdownWhileShowing is
+ * set and the lastShownDate is before today, then we decrement
+ * browser.crashReports.unsubmittedCheck.chancesUntilSuppress.
+ */
+add_task(async function test_decrement_chances_on_other_day() {
+  let initChances = UnsubmittedCrashHandler.prefs.getIntPref(
+    "chancesUntilSuppress"
+  );
+  Assert.greater(initChances, 1, "We should start with at least 1 chance.");
+
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should be a notification");
+
+  UnsubmittedCrashHandler.uninit();
+
+  gNotificationBox.removeNotification(notification, true);
+
+  let shutdownWhileShowing = UnsubmittedCrashHandler.prefs.getBoolPref(
+    "shutdownWhileShowing"
+  );
+  Assert.ok(
+    shutdownWhileShowing,
+    "We should have noticed that we uninitted while showing " +
+      "the notification."
+  );
+
+  // Now pretend that the notification was shown yesterday.
+  let yesterday = UnsubmittedCrashHandler.dateString(
+    new Date(Date.now() - DAY)
+  );
+  UnsubmittedCrashHandler.prefs.setCharPref("lastShownDate", yesterday);
+
+  UnsubmittedCrashHandler.init();
+
+  notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.ok(notification, "There should still be a notification");
+
+  let chances = UnsubmittedCrashHandler.prefs.getIntPref(
+    "chancesUntilSuppress"
+  );
+
+  Assert.equal(
+    initChances - 1,
+    chances,
+    "We should have decremented our chances."
+  );
+  UnsubmittedCrashHandler.prefs.clearUserPref("chancesUntilSuppress");
+
+  gNotificationBox.removeNotification(notification, true);
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if we've shutdown too many times showing the
+ * notification, and we've run out of chances, then
+ * browser.crashReports.unsubmittedCheck.suppressUntilDate is
+ * set for some days into the future.
+ */
+add_task(async function test_can_suppress_after_chances() {
+  // Pretend that a notification was shown yesterday.
+  let yesterday = UnsubmittedCrashHandler.dateString(
+    new Date(Date.now() - DAY)
+  );
+  UnsubmittedCrashHandler.prefs.setCharPref("lastShownDate", yesterday);
+  UnsubmittedCrashHandler.prefs.setBoolPref("shutdownWhileShowing", true);
+  UnsubmittedCrashHandler.prefs.setIntPref("chancesUntilSuppress", 0);
+
+  await createPendingCrashReports(1);
+  let notification =
+    await UnsubmittedCrashHandler.checkForUnsubmittedCrashReports();
+  Assert.equal(
+    notification,
+    null,
+    "There should be no notification if we've run out of chances"
+  );
+
+  // We should have set suppressUntilDate into the future
+  let suppressUntilDate =
+    UnsubmittedCrashHandler.prefs.getCharPref("suppressUntilDate");
+
+  let today = UnsubmittedCrashHandler.dateString(new Date());
+  Assert.ok(
+    suppressUntilDate > today,
+    "We should be suppressing until some days into the future."
+  );
+
+  UnsubmittedCrashHandler.prefs.clearUserPref("chancesUntilSuppress");
+  UnsubmittedCrashHandler.prefs.clearUserPref("suppressUntilDate");
+  UnsubmittedCrashHandler.prefs.clearUserPref("lastShownDate");
+  clearPendingCrashReports();
+});
+
+/**
+ * Tests that if there's a suppression date set, then no notification
+ * will be shown even if there are pending crash reports.
+ */
+add_task(async function test_suppression() {
+  let future = UnsubmittedCrashHandler.dateString(
+    new Date(Date.now() + DAY * 5)
+  );
+  UnsubmittedCrashHandler.prefs.setCharPref("suppressUntilDate", future);
+  UnsubmittedCrashHandler.uninit();
+  UnsubmittedCrashHandler.init();
+
+  Assert.ok(
+    UnsubmittedCrashHandler.suppressed,
+    "The UnsubmittedCrashHandler should be suppressed."
+  );
+  UnsubmittedCrashHandler.prefs.clearUserPref("suppressUntilDate");
+
+  UnsubmittedCrashHandler.uninit();
+  UnsubmittedCrashHandler.init();
+});
+
+/**
+ * Tests that if there's a suppression date set, but we've exceeded
+ * it, then we can show the notification again.
+ */
+add_task(async function test_end_suppression() {
+  let yesterday = UnsubmittedCrashHandler.dateString(
+    new Date(Date.now() - DAY)
+  );
+  UnsubmittedCrashHandler.prefs.setCharPref("suppressUntilDate", yesterday);
+  UnsubmittedCrashHandler.uninit();
+  UnsubmittedCrashHandler.init();
+
+  Assert.ok(
+    !UnsubmittedCrashHandler.suppressed,
+    "The UnsubmittedCrashHandler should not be suppressed."
+  );
+  Assert.ok(
+    !UnsubmittedCrashHandler.prefs.prefHasUserValue("suppressUntilDate"),
+    "The suppression date should been cleared from preferences."
+  );
+
+  UnsubmittedCrashHandler.uninit();
+  UnsubmittedCrashHandler.init();
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry.js b/browser/modules/test/browser/browser_UsageTelemetry.js
new file mode 100644
index 0000000000..9934723f37
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry.js
@@ -0,0 +1,696 @@
+"use strict";
+
+requestLongerTimeout(2);
+
+const MAX_CONCURRENT_TABS = "browser.engagement.max_concurrent_tab_count";
+const TAB_EVENT_COUNT = "browser.engagement.tab_open_event_count";
+const MAX_CONCURRENT_WINDOWS = "browser.engagement.max_concurrent_window_count";
+const MAX_TAB_PINNED = "browser.engagement.max_concurrent_tab_pinned_count";
+const TAB_PINNED_EVENT = "browser.engagement.tab_pinned_event_count";
+const WINDOW_OPEN_COUNT = "browser.engagement.window_open_event_count";
+const TOTAL_URI_COUNT = "browser.engagement.total_uri_count";
+const UNIQUE_DOMAINS_COUNT = "browser.engagement.unique_domains_count";
+const UNFILTERED_URI_COUNT = "browser.engagement.unfiltered_uri_count";
+const TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE =
+  "browser.engagement.total_uri_count_normal_and_private_mode";
+
+const TELEMETRY_SUBSESSION_TOPIC = "internal-telemetry-after-subsession-split";
+
+const RESTORE_ON_DEMAND_PREF = "browser.sessionstore.restore_on-demand";
+
+ChromeUtils.defineESModuleGetters(this, {
+  MINIMUM_TAB_COUNT_INTERVAL_MS:
+    "resource:///modules/BrowserUsageTelemetry.sys.mjs",
+});
+
+const { ObjectUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/ObjectUtils.sys.mjs"
+);
+
+BrowserUsageTelemetry._onTabsOpenedTask._timeoutMs = 0;
+registerCleanupFunction(() => {
+  BrowserUsageTelemetry._onTabsOpenedTask._timeoutMs = undefined;
+});
+
+// Reset internal URI counter in case URIs were opened by other tests.
+Services.obs.notifyObservers(null, TELEMETRY_SUBSESSION_TOPIC);
+
+/**
+ * Get a snapshot of the scalars and check them against the provided values.
+ */
+let checkScalars = (countsObject, skipGleanCheck = false) => {
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  // Check the expected values. Scalars that are never set must not be reported.
+  const checkScalar = (key, val, msg) =>
+    val > 0
+      ? TelemetryTestUtils.assertScalar(scalars, key, val, msg)
+      : TelemetryTestUtils.assertScalarUnset(scalars, key);
+  checkScalar(
+    MAX_CONCURRENT_TABS,
+    countsObject.maxTabs,
+    "The maximum tab count must match the expected value."
+  );
+  checkScalar(
+    TAB_EVENT_COUNT,
+    countsObject.tabOpenCount,
+    "The number of open tab event count must match the expected value."
+  );
+  checkScalar(
+    MAX_TAB_PINNED,
+    countsObject.maxTabsPinned,
+    "The maximum tabs pinned count must match the expected value."
+  );
+  checkScalar(
+    TAB_PINNED_EVENT,
+    countsObject.tabPinnedCount,
+    "The number of tab pinned event count must match the expected value."
+  );
+  checkScalar(
+    MAX_CONCURRENT_WINDOWS,
+    countsObject.maxWindows,
+    "The maximum window count must match the expected value."
+  );
+  checkScalar(
+    WINDOW_OPEN_COUNT,
+    countsObject.windowsOpenCount,
+    "The number of window open event count must match the expected value."
+  );
+  checkScalar(
+    TOTAL_URI_COUNT,
+    countsObject.totalURIs,
+    "The total URI count must match the expected value."
+  );
+  checkScalar(
+    UNIQUE_DOMAINS_COUNT,
+    countsObject.domainCount,
+    "The unique domains count must match the expected value."
+  );
+  checkScalar(
+    UNFILTERED_URI_COUNT,
+    countsObject.totalUnfilteredURIs,
+    "The unfiltered URI count must match the expected value."
+  );
+  checkScalar(
+    TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE,
+    countsObject.totalURIsNormalAndPrivateMode,
+    "The total URI count for both normal and private mode must match the expected value."
+  );
+  if (!skipGleanCheck) {
+    if (countsObject.totalURIsNormalAndPrivateMode == 0) {
+      Assert.equal(
+        Glean.browserEngagement.uriCount.testGetValue(),
+        undefined,
+        "Total URI count reported in Glean must be unset."
+      );
+    } else {
+      Assert.equal(
+        countsObject.totalURIsNormalAndPrivateMode,
+        Glean.browserEngagement.uriCount.testGetValue(),
+        "The total URI count reported in Glean must be as expected."
+      );
+    }
+  }
+};
+
+add_task(async function test_tabsAndWindows() {
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+  Services.fog.testResetFOG();
+
+  let openedTabs = [];
+  let expectedTabOpenCount = 0;
+  let expectedWinOpenCount = 0;
+  let expectedMaxTabs = 0;
+  let expectedMaxWins = 0;
+  let expectedMaxTabsPinned = 0;
+  let expectedTabPinned = 0;
+  let expectedTotalURIs = 0;
+
+  // Add a new tab and check that the count is right.
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+
+  gBrowser.pinTab(openedTabs[0]);
+  gBrowser.unpinTab(openedTabs[0]);
+
+  expectedTabOpenCount = 1;
+  expectedMaxTabs = 2;
+  expectedMaxTabsPinned = 1;
+  expectedTabPinned += 1;
+  // This, and all the checks below, also check that initial pages (about:newtab, about:blank, ..)
+  // are not counted by the total_uri_count and the unfiltered_uri_count probes.
+  checkScalars({
+    maxTabs: expectedMaxTabs,
+    tabOpenCount: expectedTabOpenCount,
+    maxWindows: expectedMaxWins,
+    windowsOpenCount: expectedWinOpenCount,
+    totalURIs: expectedTotalURIs,
+    domainCount: 0,
+    totalUnfilteredURIs: 0,
+    maxTabsPinned: expectedMaxTabsPinned,
+    tabPinnedCount: expectedTabPinned,
+    totalURIsNormalAndPrivateMode: expectedTotalURIs,
+  });
+
+  // Add two new tabs in the same window.
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+
+  gBrowser.pinTab(openedTabs[1]);
+  gBrowser.pinTab(openedTabs[2]);
+  gBrowser.unpinTab(openedTabs[2]);
+  gBrowser.unpinTab(openedTabs[1]);
+
+  expectedTabOpenCount += 2;
+  expectedMaxTabs += 2;
+  expectedMaxTabsPinned = 2;
+  expectedTabPinned += 2;
+  checkScalars({
+    maxTabs: expectedMaxTabs,
+    tabOpenCount: expectedTabOpenCount,
+    maxWindows: expectedMaxWins,
+    windowsOpenCount: expectedWinOpenCount,
+    totalURIs: expectedTotalURIs,
+    domainCount: 0,
+    totalUnfilteredURIs: 0,
+    maxTabsPinned: expectedMaxTabsPinned,
+    tabPinnedCount: expectedTabPinned,
+    totalURIsNormalAndPrivateMode: expectedTotalURIs,
+  });
+
+  // Add a new window and then some tabs in it. An empty new windows counts as a tab.
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.firstBrowserLoaded(win);
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:blank")
+  );
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:blank")
+  );
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+  // The new window started with a new tab, so account for it.
+  expectedTabOpenCount += 4;
+  expectedWinOpenCount += 1;
+  expectedMaxWins = 2;
+  expectedMaxTabs += 4;
+
+  // Remove a tab from the first window, the max shouldn't change.
+  BrowserTestUtils.removeTab(openedTabs.pop());
+  checkScalars({
+    maxTabs: expectedMaxTabs,
+    tabOpenCount: expectedTabOpenCount,
+    maxWindows: expectedMaxWins,
+    windowsOpenCount: expectedWinOpenCount,
+    totalURIs: expectedTotalURIs,
+    domainCount: 0,
+    totalUnfilteredURIs: 0,
+    maxTabsPinned: expectedMaxTabsPinned,
+    tabPinnedCount: expectedTabPinned,
+    totalURIsNormalAndPrivateMode: expectedTotalURIs,
+  });
+
+  // Remove all the extra windows and tabs.
+  for (let tab of openedTabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+  await BrowserTestUtils.closeWindow(win);
+
+  // Make sure all the scalars still have the expected values.
+  checkScalars({
+    maxTabs: expectedMaxTabs,
+    tabOpenCount: expectedTabOpenCount,
+    maxWindows: expectedMaxWins,
+    windowsOpenCount: expectedWinOpenCount,
+    totalURIs: expectedTotalURIs,
+    domainCount: 0,
+    totalUnfilteredURIs: 0,
+    maxTabsPinned: expectedMaxTabsPinned,
+    tabPinnedCount: expectedTabPinned,
+    totalURIsNormalAndPrivateMode: expectedTotalURIs,
+  });
+});
+
+add_task(async function test_subsessionSplit() {
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+
+  // Add a new window (that will have 4 tabs).
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.firstBrowserLoaded(win);
+  let openedTabs = [];
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:blank")
+  );
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:mozilla")
+  );
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(
+      win.gBrowser,
+      "http://www.example.com"
+    )
+  );
+
+  // Check that the scalars have the right values. We expect 2 unfiltered URI loads
+  // (about:mozilla and www.example.com, but no about:blank) and 1 URI totalURIs
+  // (only www.example.com).
+  let expectedTotalURIs = 1;
+
+  checkScalars({
+    maxTabs: 5,
+    tabOpenCount: 4,
+    maxWindows: 2,
+    windowsOpenCount: 1,
+    totalURIs: expectedTotalURIs,
+    domainCount: 1,
+    totalUnfilteredURIs: 2,
+    maxTabsPinned: 0,
+    tabPinnedCount: 0,
+    totalURIsNormalAndPrivateMode: expectedTotalURIs,
+  });
+
+  // Remove a tab.
+  BrowserTestUtils.removeTab(openedTabs.pop());
+
+  // Simulate a subsession split by clearing the scalars (via |getSnapshotForScalars|) and
+  // notifying the subsession split topic.
+  Services.telemetry.getSnapshotForScalars("main", true /* clearScalars */);
+  Services.obs.notifyObservers(null, TELEMETRY_SUBSESSION_TOPIC);
+
+  // After a subsession split, only the MAX_CONCURRENT_* scalars must be available
+  // and have the correct value. No tabs, windows or URIs were opened so other scalars
+  // must not be reported.
+  expectedTotalURIs = 0;
+
+  checkScalars(
+    {
+      maxTabs: 4,
+      tabOpenCount: 0,
+      maxWindows: 2,
+      windowsOpenCount: 0,
+      totalURIs: expectedTotalURIs,
+      domainCount: 0,
+      totalUnfilteredURIs: 0,
+      maxTabsPinned: 0,
+      tabPinnedCount: 0,
+      totalURIsNormalAndPrivateMode: expectedTotalURIs,
+    },
+    true
+  );
+
+  // Remove all the extra windows and tabs.
+  for (let tab of openedTabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+  await BrowserTestUtils.closeWindow(win);
+});
+
+function checkTabCountHistogram(result, expected, message) {
+  Assert.deepEqual(result.values, expected, message);
+}
+
+add_task(async function test_tabsHistogram() {
+  let openedTabs = [];
+  let tabCountHist = TelemetryTestUtils.getAndClearHistogram("TAB_COUNT");
+
+  checkTabCountHistogram(
+    tabCountHist.snapshot(),
+    {},
+    "TAB_COUNT telemetry - initial tab counts"
+  );
+
+  // Add a new tab and check that the count is right.
+  BrowserUsageTelemetry._lastRecordTabCount = 0;
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+  checkTabCountHistogram(
+    tabCountHist.snapshot(),
+    { 1: 0, 2: 1, 3: 0 },
+    "TAB_COUNT telemetry - opening tabs"
+  );
+
+  // Open a different page and check the counts.
+  BrowserUsageTelemetry._lastRecordTabCount = 0;
+  let tab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  openedTabs.push(tab);
+  BrowserUsageTelemetry._lastRecordTabCount = 0;
+  BrowserTestUtils.startLoadingURIString(
+    tab.linkedBrowser,
+    "http://example.com/"
+  );
+  await BrowserTestUtils.browserLoaded(
+    tab.linkedBrowser,
+    false,
+    "http://example.com/"
+  );
+  checkTabCountHistogram(
+    tabCountHist.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 0 },
+    "TAB_COUNT telemetry - loading page"
+  );
+
+  // Open another tab
+  BrowserUsageTelemetry._lastRecordTabCount = 0;
+  openedTabs.push(
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank")
+  );
+  checkTabCountHistogram(
+    tabCountHist.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 1, 5: 0 },
+    "TAB_COUNT telemetry - opening more tabs"
+  );
+
+  // Add a new window and then some tabs in it. A new window starts with one tab.
+  BrowserUsageTelemetry._lastRecordTabCount = 0;
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.firstBrowserLoaded(win);
+  checkTabCountHistogram(
+    tabCountHist.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 6: 0 },
+    "TAB_COUNT telemetry - opening window"
+  );
+
+  // Do not trigger a recount if _lastRecordTabCount is recent on new tab
+  BrowserUsageTelemetry._lastRecordTabCount =
+    Date.now() - MINIMUM_TAB_COUNT_INTERVAL_MS / 2;
+  {
+    let oldLastRecordTabCount = BrowserUsageTelemetry._lastRecordTabCount;
+    openedTabs.push(
+      await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:blank")
+    );
+    checkTabCountHistogram(
+      tabCountHist.snapshot(),
+      { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 6: 0 },
+      "TAB_COUNT telemetry - new tab, recount event ignored"
+    );
+    Assert.equal(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      oldLastRecordTabCount,
+      "TAB_COUNT telemetry - _lastRecordTabCount unchanged"
+    );
+  }
+
+  // Trigger a recount if _lastRecordTabCount has passed on new tab
+  BrowserUsageTelemetry._lastRecordTabCount =
+    Date.now() - (MINIMUM_TAB_COUNT_INTERVAL_MS + 1000);
+  {
+    let oldLastRecordTabCount = BrowserUsageTelemetry._lastRecordTabCount;
+    openedTabs.push(
+      await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:blank")
+    );
+    checkTabCountHistogram(
+      tabCountHist.snapshot(),
+      { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 7: 1, 8: 0 },
+      "TAB_COUNT telemetry - new tab, recount event included"
+    );
+    Assert.notEqual(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      oldLastRecordTabCount,
+      "TAB_COUNT telemetry - _lastRecordTabCount updated"
+    );
+    Assert.greater(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      Date.now() - MINIMUM_TAB_COUNT_INTERVAL_MS,
+      "TAB_COUNT telemetry - _lastRecordTabCount invariant"
+    );
+  }
+
+  // Do not trigger a recount if _lastRecordTabCount is recent on page load
+  BrowserUsageTelemetry._lastRecordTabCount =
+    Date.now() - MINIMUM_TAB_COUNT_INTERVAL_MS / 2;
+  {
+    let oldLastRecordTabCount = BrowserUsageTelemetry._lastRecordTabCount;
+    BrowserTestUtils.startLoadingURIString(
+      tab.linkedBrowser,
+      "http://example.com/"
+    );
+    await BrowserTestUtils.browserLoaded(
+      tab.linkedBrowser,
+      false,
+      "http://example.com/"
+    );
+    checkTabCountHistogram(
+      tabCountHist.snapshot(),
+      { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 7: 1, 8: 0 },
+      "TAB_COUNT telemetry - page load, recount event ignored"
+    );
+    Assert.equal(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      oldLastRecordTabCount,
+      "TAB_COUNT telemetry - _lastRecordTabCount unchanged"
+    );
+  }
+
+  // Trigger a recount if _lastRecordTabCount has passed on page load
+  BrowserUsageTelemetry._lastRecordTabCount =
+    Date.now() - (MINIMUM_TAB_COUNT_INTERVAL_MS + 1000);
+  {
+    let oldLastRecordTabCount = BrowserUsageTelemetry._lastRecordTabCount;
+    BrowserTestUtils.startLoadingURIString(
+      tab.linkedBrowser,
+      "http://example.com/"
+    );
+    await BrowserTestUtils.browserLoaded(
+      tab.linkedBrowser,
+      false,
+      "http://example.com/"
+    );
+    checkTabCountHistogram(
+      tabCountHist.snapshot(),
+      { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 7: 2, 8: 0 },
+      "TAB_COUNT telemetry - page load, recount event included"
+    );
+    Assert.notEqual(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      oldLastRecordTabCount,
+      "TAB_COUNT telemetry - _lastRecordTabCount updated"
+    );
+    Assert.greater(
+      BrowserUsageTelemetry._lastRecordTabCount,
+      Date.now() - MINIMUM_TAB_COUNT_INTERVAL_MS,
+      "TAB_COUNT telemetry - _lastRecordTabCount invariant"
+    );
+  }
+
+  // Remove all the extra windows and tabs.
+  for (let openTab of openedTabs) {
+    BrowserTestUtils.removeTab(openTab);
+  }
+  await BrowserTestUtils.closeWindow(win);
+});
+
+add_task(async function test_loadedTabsHistogram() {
+  Services.prefs.setBoolPref(RESTORE_ON_DEMAND_PREF, true);
+  registerCleanupFunction(() =>
+    Services.prefs.clearUserPref(RESTORE_ON_DEMAND_PREF)
+  );
+
+  function resetTimestamps() {
+    BrowserUsageTelemetry._lastRecordTabCount = 0;
+    BrowserUsageTelemetry._lastRecordLoadedTabCount = 0;
+  }
+
+  resetTimestamps();
+  const tabCount = TelemetryTestUtils.getAndClearHistogram("TAB_COUNT");
+  const loadedTabCount =
+    TelemetryTestUtils.getAndClearHistogram("LOADED_TAB_COUNT");
+
+  checkTabCountHistogram(tabCount.snapshot(), {}, "TAB_COUNT - initial count");
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    {},
+    "LOADED_TAB_COUNT - initial count"
+  );
+
+  resetTimestamps();
+  const tabs = [
+    await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank"),
+  ];
+
+  // There are two tabs open: the mochi.test tab and the foreground tab.
+  const snapshot = loadedTabCount.snapshot();
+  checkTabCountHistogram(snapshot, { 1: 0, 2: 1, 3: 0 }, "TAB_COUNT - new tab");
+
+  // Open a pending tab, as if by session restore.
+  resetTimestamps();
+  const lazyTab = BrowserTestUtils.addTab(gBrowser, "about:mozilla", {
+    createLazyBrowser: true,
+  });
+  tabs.push(lazyTab);
+
+  await BrowserTestUtils.waitForCondition(
+    () => !ObjectUtils.deepEqual(snapshot, tabCount.snapshot())
+  );
+
+  checkTabCountHistogram(
+    tabCount.snapshot(),
+    { 1: 0, 2: 1, 3: 1, 4: 0 },
+    "TAB_COUNT - Added pending tab"
+  );
+
+  // Only the mochi.test and foreground tab are loaded.
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    { 1: 0, 2: 2, 3: 0 },
+    "LOADED_TAB_COUNT - Added pending tab"
+  );
+
+  resetTimestamps();
+  const restoredEvent = BrowserTestUtils.waitForEvent(lazyTab, "SSTabRestored");
+  await BrowserTestUtils.switchTab(gBrowser, lazyTab);
+  await restoredEvent;
+
+  checkTabCountHistogram(
+    tabCount.snapshot(),
+    { 1: 0, 2: 1, 3: 1, 4: 0 },
+    "TAB_COUNT - Restored pending tab"
+  );
+
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    { 1: 0, 2: 2, 3: 1, 4: 0 },
+    "LOADED_TAB_COUNT - Restored pending tab"
+  );
+
+  resetTimestamps();
+
+  await Promise.all([
+    BrowserTestUtils.startLoadingURIString(
+      lazyTab.linkedBrowser,
+      "http://example.com/"
+    ),
+    BrowserTestUtils.browserLoaded(
+      lazyTab.linkedBrowser,
+      false,
+      "http://example.com/"
+    ),
+  ]);
+
+  checkTabCountHistogram(
+    tabCount.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 0 },
+    "TAB_COUNT - Navigated in existing tab"
+  );
+
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    { 1: 0, 2: 2, 3: 2, 4: 0 },
+    "LOADED_TAB_COUNT - Navigated in existing tab"
+  );
+
+  resetTimestamps();
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.firstBrowserLoaded(win);
+
+  // The new window will have a new tab.
+  checkTabCountHistogram(
+    tabCount.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 1, 5: 0 },
+    "TAB_COUNT - Opened new window"
+  );
+
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    { 1: 0, 2: 2, 3: 2, 4: 1, 5: 0 },
+    "LOADED_TAB_COUNT - Opened new window"
+  );
+
+  resetTimestamps();
+  await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "about:robots");
+  checkTabCountHistogram(
+    tabCount.snapshot(),
+    { 1: 0, 2: 1, 3: 2, 4: 1, 5: 1, 6: 0 },
+    "TAB_COUNT - Opened new tab in new window"
+  );
+
+  checkTabCountHistogram(
+    loadedTabCount.snapshot(),
+    { 1: 0, 2: 2, 3: 2, 4: 1, 5: 1, 6: 0 },
+    "LOADED_TAB_COUNT - Opened new tab in new window"
+  );
+
+  for (const tab of tabs) {
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  await BrowserTestUtils.closeWindow(win);
+});
+
+add_task(async function test_restored_max_pinned_count() {
+  // Following pinned tab testing example from
+  // https://searchfox.org/mozilla-central/rev/1843375acbbca68127713e402be222350ac99301/browser/components/sessionstore/test/browser_pinned_tabs.js
+  Services.telemetry.clearScalars();
+  const { E10SUtils } = ChromeUtils.importESModule(
+    "resource://gre/modules/E10SUtils.sys.mjs"
+  );
+  const BACKUP_STATE = SessionStore.getBrowserState();
+  const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL;
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["browser.sessionstore.restore_on_demand", true],
+      ["browser.sessionstore.restore_tabs_lazily", true],
+    ],
+  });
+  let sessionRestoredPromise = new Promise(resolve => {
+    Services.obs.addObserver(resolve, "sessionstore-browser-state-restored");
+  });
+
+  info("Set browser state to 1 pinned tab.");
+  await SessionStore.setBrowserState(
+    JSON.stringify({
+      windows: [
+        {
+          selected: 1,
+          tabs: [
+            {
+              pinned: true,
+              entries: [
+                { url: "https://example.com", triggeringPrincipal_base64 },
+              ],
+            },
+          ],
+        },
+      ],
+    })
+  );
+
+  info("Await `sessionstore-browser-state-restored` promise.");
+  await sessionRestoredPromise;
+
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  TelemetryTestUtils.assertScalar(
+    scalars,
+    MAX_TAB_PINNED,
+    1,
+    "The maximum tabs pinned count must match the expected value."
+  );
+
+  gBrowser.unpinTab(gBrowser.selectedTab);
+
+  TelemetryTestUtils.assertScalar(
+    scalars,
+    MAX_TAB_PINNED,
+    1,
+    "The maximum tabs pinned count must match the expected value."
+  );
+
+  sessionRestoredPromise = new Promise(resolve => {
+    Services.obs.addObserver(resolve, "sessionstore-browser-state-restored");
+  });
+  await SessionStore.setBrowserState(BACKUP_STATE);
+  await SpecialPowers.popPrefEnv();
+  await sessionRestoredPromise;
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_content_aboutRestartRequired.js b/browser/modules/test/browser/browser_UsageTelemetry_content_aboutRestartRequired.js
new file mode 100644
index 0000000000..3baa336d79
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_content_aboutRestartRequired.js
@@ -0,0 +1,33 @@
+"use strict";
+
+const SCALAR_BUILDID_MISMATCH = "dom.contentprocess.buildID_mismatch";
+
+add_task(async function test_aboutRestartRequired() {
+  const { TabCrashHandler } = ChromeUtils.importESModule(
+    "resource:///modules/ContentCrashHandlers.sys.mjs"
+  );
+
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+
+  let scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  // Check preconditions
+  is(
+    scalars[SCALAR_BUILDID_MISMATCH],
+    undefined,
+    "Build ID mismatch count should be undefined"
+  );
+
+  // Simulate buildID mismatch
+  TabCrashHandler._crashedTabCount = 1;
+  TabCrashHandler.sendToRestartRequiredPage(gBrowser.selectedTab.linkedBrowser);
+
+  scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  is(
+    scalars[SCALAR_BUILDID_MISMATCH],
+    1,
+    "Build ID mismatch count should be 1."
+  );
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_domains.js b/browser/modules/test/browser/browser_UsageTelemetry_domains.js
new file mode 100644
index 0000000000..453272ea6b
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_domains.js
@@ -0,0 +1,196 @@
+"use strict";
+
+const TOTAL_URI_COUNT = "browser.engagement.total_uri_count";
+const UNIQUE_DOMAINS_COUNT = "browser.engagement.unique_domains_count";
+const UNFILTERED_URI_COUNT = "browser.engagement.unfiltered_uri_count";
+const TELEMETRY_SUBSESSION_TOPIC = "internal-telemetry-after-subsession-split";
+
+// Reset internal URI counter in case URIs were opened by other tests.
+Services.obs.notifyObservers(null, TELEMETRY_SUBSESSION_TOPIC);
+
+/**
+ * Waits for the web progress listener associated with this tab to fire an
+ * onLocationChange for a non-error page.
+ *
+ * @param {xul:browser} browser
+ *        A xul:browser.
+ *
+ * @return {Promise}
+ * @resolves When navigating to a non-error page.
+ */
+function browserLocationChanged(browser) {
+  return new Promise(resolve => {
+    let wpl = {
+      onStateChange() {},
+      onSecurityChange() {},
+      onStatusChange() {},
+      onContentBlockingEvent() {},
+      onLocationChange(aWebProgress, aRequest, aURI, aFlags) {
+        if (!(aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE)) {
+          browser.webProgress.removeProgressListener(filter);
+          filter.removeProgressListener(wpl);
+          resolve();
+        }
+      },
+      QueryInterface: ChromeUtils.generateQI([
+        "nsIWebProgressListener",
+        "nsIWebProgressListener2",
+      ]),
+    };
+    const filter = Cc[
+      "@mozilla.org/appshell/component/browser-status-filter;1"
+    ].createInstance(Ci.nsIWebProgress);
+    filter.addProgressListener(wpl, Ci.nsIWebProgress.NOTIFY_ALL);
+    browser.webProgress.addProgressListener(
+      filter,
+      Ci.nsIWebProgress.NOTIFY_ALL
+    );
+  });
+}
+
+add_task(async function test_URIAndDomainCounts() {
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+
+  let checkCounts = countsObject => {
+    // Get a snapshot of the scalars and then clear them.
+    const scalars = TelemetryTestUtils.getProcessScalars("parent");
+    TelemetryTestUtils.assertScalar(
+      scalars,
+      TOTAL_URI_COUNT,
+      countsObject.totalURIs,
+      "The URI scalar must contain the expected value."
+    );
+    TelemetryTestUtils.assertScalar(
+      scalars,
+      UNIQUE_DOMAINS_COUNT,
+      countsObject.domainCount,
+      "The unique domains scalar must contain the expected value."
+    );
+    TelemetryTestUtils.assertScalar(
+      scalars,
+      UNFILTERED_URI_COUNT,
+      countsObject.totalUnfilteredURIs,
+      "The unfiltered URI scalar must contain the expected value."
+    );
+  };
+
+  // Check that about:blank doesn't get counted in the URI total.
+  let firstTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  TelemetryTestUtils.assertScalarUnset(
+    TelemetryTestUtils.getProcessScalars("parent"),
+    TOTAL_URI_COUNT
+  );
+  TelemetryTestUtils.assertScalarUnset(
+    TelemetryTestUtils.getProcessScalars("parent"),
+    UNIQUE_DOMAINS_COUNT
+  );
+  TelemetryTestUtils.assertScalarUnset(
+    TelemetryTestUtils.getProcessScalars("parent"),
+    UNFILTERED_URI_COUNT
+  );
+
+  // Open a different page and check the counts.
+  BrowserTestUtils.startLoadingURIString(
+    firstTab.linkedBrowser,
+    "http://example.com/"
+  );
+  await BrowserTestUtils.browserLoaded(firstTab.linkedBrowser);
+  checkCounts({ totalURIs: 1, domainCount: 1, totalUnfilteredURIs: 1 });
+
+  // Activating a different tab must not increase the URI count.
+  let secondTab = await BrowserTestUtils.openNewForegroundTab(
+    gBrowser,
+    "about:blank"
+  );
+  await BrowserTestUtils.switchTab(gBrowser, firstTab);
+  checkCounts({ totalURIs: 1, domainCount: 1, totalUnfilteredURIs: 1 });
+  BrowserTestUtils.removeTab(secondTab);
+
+  // Open a new window and set the tab to a new address.
+  let newWin = await BrowserTestUtils.openNewBrowserWindow();
+  BrowserTestUtils.startLoadingURIString(
+    newWin.gBrowser.selectedBrowser,
+    "http://example.com/"
+  );
+  await BrowserTestUtils.browserLoaded(newWin.gBrowser.selectedBrowser);
+  checkCounts({ totalURIs: 2, domainCount: 1, totalUnfilteredURIs: 2 });
+
+  // We should not count AJAX requests.
+  const XHR_URL = "http://example.com/r";
+  await SpecialPowers.spawn(
+    newWin.gBrowser.selectedBrowser,
+    [XHR_URL],
+    function (url) {
+      return new Promise(resolve => {
+        var xhr = new content.window.XMLHttpRequest();
+        xhr.open("GET", url);
+        xhr.onload = () => resolve();
+        xhr.send();
+      });
+    }
+  );
+  checkCounts({ totalURIs: 2, domainCount: 1, totalUnfilteredURIs: 2 });
+
+  // Check that we're counting page fragments.
+  let loadingStopped = browserLocationChanged(newWin.gBrowser.selectedBrowser);
+  BrowserTestUtils.startLoadingURIString(
+    newWin.gBrowser.selectedBrowser,
+    "http://example.com/#2"
+  );
+  await loadingStopped;
+  checkCounts({ totalURIs: 3, domainCount: 1, totalUnfilteredURIs: 3 });
+
+  // Check that a different URI from the example.com domain doesn't increment the unique count.
+  BrowserTestUtils.startLoadingURIString(
+    newWin.gBrowser.selectedBrowser,
+    "http://test1.example.com/"
+  );
+  await BrowserTestUtils.browserLoaded(newWin.gBrowser.selectedBrowser);
+  checkCounts({ totalURIs: 4, domainCount: 1, totalUnfilteredURIs: 4 });
+
+  // Make sure that the unique domains counter is incrementing for a different domain.
+  BrowserTestUtils.startLoadingURIString(
+    newWin.gBrowser.selectedBrowser,
+    "https://example.org/"
+  );
+  await BrowserTestUtils.browserLoaded(newWin.gBrowser.selectedBrowser);
+  checkCounts({ totalURIs: 5, domainCount: 2, totalUnfilteredURIs: 5 });
+
+  // Check that we only account for top level loads (e.g. we don't count URIs from
+  // embedded iframes).
+  await SpecialPowers.spawn(
+    newWin.gBrowser.selectedBrowser,
+    [],
+    async function () {
+      let doc = content.document;
+      let iframe = doc.createElement("iframe");
+      let promiseIframeLoaded = ContentTaskUtils.waitForEvent(
+        iframe,
+        "load",
+        false
+      );
+      iframe.src = "https://example.org/test";
+      doc.body.insertBefore(iframe, doc.body.firstElementChild);
+      await promiseIframeLoaded;
+    }
+  );
+  checkCounts({ totalURIs: 5, domainCount: 2, totalUnfilteredURIs: 5 });
+
+  // Check that uncommon protocols get counted in the unfiltered URI probe.
+  const TEST_PAGE =
+    "data:text/html,<a id='target' href='%23par1'>Click me</a><a name='par1'>The paragraph.</a>";
+  BrowserTestUtils.startLoadingURIString(
+    newWin.gBrowser.selectedBrowser,
+    TEST_PAGE
+  );
+  await BrowserTestUtils.browserLoaded(newWin.gBrowser.selectedBrowser);
+  checkCounts({ totalURIs: 5, domainCount: 2, totalUnfilteredURIs: 6 });
+
+  // Clean up.
+  BrowserTestUtils.removeTab(firstTab);
+  await BrowserTestUtils.closeWindow(newWin);
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_interaction.js b/browser/modules/test/browser/browser_UsageTelemetry_interaction.js
new file mode 100644
index 0000000000..2bc60d9697
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_interaction.js
@@ -0,0 +1,955 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+gReduceMotionOverride = true;
+
+const AREAS = [
+  "keyboard",
+  "menu_bar",
+  "tabs_bar",
+  "nav_bar",
+  "bookmarks_bar",
+  "app_menu",
+  "tabs_context",
+  "content_context",
+  "overflow_menu",
+  "pinned_overflow_menu",
+  "pageaction_urlbar",
+  "pageaction_panel",
+
+  "preferences_paneHome",
+  "preferences_paneGeneral",
+  "preferences_panePrivacy",
+  "preferences_paneSearch",
+  "preferences_paneSearchResults",
+  "preferences_paneSync",
+  "preferences_paneContainers",
+];
+
+// Checks that the correct number of clicks are registered against the correct
+// keys in the scalars. Also runs keyed scalar checks against non-area types
+// passed in through expectedOther.
+function assertInteractionScalars(expectedAreas, expectedOther = {}) {
+  let processScalars =
+    Services.telemetry.getSnapshotForKeyedScalars("main", true)?.parent ?? {};
+
+  let compareSourceWithExpectations = (source, expected = {}) => {
+    let scalars = processScalars?.[`browser.ui.interaction.${source}`] ?? {};
+
+    let expectedKeys = new Set(
+      Object.keys(scalars).concat(Object.keys(expected))
+    );
+
+    for (let key of expectedKeys) {
+      Assert.equal(
+        scalars[key],
+        expected[key],
+        `Expected to see the correct value for ${key} in ${source}.`
+      );
+    }
+  };
+
+  for (let source of AREAS) {
+    compareSourceWithExpectations(source, expectedAreas[source]);
+  }
+
+  for (let source in expectedOther) {
+    compareSourceWithExpectations(source, expectedOther[source]);
+  }
+}
+
+const elem = id => document.getElementById(id);
+const click = el => {
+  if (typeof el == "string") {
+    el = elem(el);
+  }
+
+  EventUtils.synthesizeMouseAtCenter(el, {}, window);
+};
+
+add_task(async function toolbarButtons() {
+  await BrowserTestUtils.withNewTab("https://example.com", async () => {
+    let customButton = await new Promise(resolve => {
+      CustomizableUI.createWidget({
+        // In CSS identifiers cannot start with a number but CustomizableUI accepts that.
+        id: "12foo",
+        label: "12foo",
+        onCreated: resolve,
+        defaultArea: "nav-bar",
+      });
+    });
+
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    let newTab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
+    let tabClose = BrowserTestUtils.waitForTabClosing(newTab);
+
+    let tabs = elem("tabbrowser-tabs");
+    if (!tabs.hasAttribute("overflow")) {
+      tabs.setAttribute("overflow", "true");
+      registerCleanupFunction(() => {
+        tabs.removeAttribute("overflow");
+      });
+    }
+
+    // We intentionally turn off a11y_checks for these click events, because the
+    // test is checking the telemetry functionality and the following 3 clicks
+    // are targeting disabled controls to test the changes in scalars (for more
+    // refer to the bug 1864576 comment 2 and bug 1854999 comment 4):
+    AccessibilityUtils.setEnv({
+      mustBeEnabled: false,
+    });
+    click("stop-reload-button");
+    click("back-button");
+    click("back-button");
+    AccessibilityUtils.resetEnv();
+
+    // Make sure the all tabs panel is in the document.
+    gTabsPanel.initElements();
+    let view = elem("allTabsMenu-allTabsView");
+    let shown = BrowserTestUtils.waitForEvent(view, "ViewShown");
+    click("alltabs-button");
+    await shown;
+
+    let hidden = BrowserTestUtils.waitForEvent(view, "ViewHiding");
+    gTabsPanel.hideAllTabsPanel();
+    await hidden;
+
+    click(newTab.querySelector(".tab-close-button"));
+    await tabClose;
+
+    let bookmarksToolbar = gNavToolbox.querySelector("#PersonalToolbar");
+
+    let bookmarksToolbarReady = BrowserTestUtils.waitForMutationCondition(
+      bookmarksToolbar,
+      { attributes: true },
+      () => {
+        return (
+          bookmarksToolbar.getAttribute("collapsed") != "true" &&
+          bookmarksToolbar.getAttribute("initialized") == "true"
+        );
+      }
+    );
+
+    window.setToolbarVisibility(
+      bookmarksToolbar,
+      true /* isVisible */,
+      false /* persist */,
+      false /* animated */
+    );
+    registerCleanupFunction(() => {
+      window.setToolbarVisibility(
+        bookmarksToolbar,
+        false /* isVisible */,
+        false /* persist */,
+        false /* animated */
+      );
+    });
+    await bookmarksToolbarReady;
+
+    // The Bookmarks Toolbar does some optimizations to try not to jank the
+    // browser when populating itself, and does so asynchronously. We wait
+    // until a bookmark item is available in the DOM before continuing.
+    let placesToolbarItems = document.getElementById("PlacesToolbarItems");
+    await BrowserTestUtils.waitForMutationCondition(
+      placesToolbarItems,
+      { childList: true },
+      () => placesToolbarItems.querySelector(".bookmark-item") != null
+    );
+
+    click(placesToolbarItems.querySelector(".bookmark-item"));
+
+    click(customButton);
+
+    assertInteractionScalars(
+      {
+        nav_bar: {
+          "stop-reload-button": 1,
+          "back-button": 2,
+          "12foo": 1,
+        },
+        tabs_bar: {
+          "alltabs-button": 1,
+          "tab-close-button": 1,
+        },
+        bookmarks_bar: {
+          "bookmark-item": 1,
+        },
+      },
+      {
+        all_tabs_panel_entrypoint: {
+          "alltabs-button": 1,
+        },
+      }
+    );
+    CustomizableUI.destroyWidget("12foo");
+  });
+});
+
+add_task(async function contextMenu() {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    let tab = gBrowser.getTabForBrowser(browser);
+    let context = elem("tabContextMenu");
+    let shown = BrowserTestUtils.waitForEvent(context, "popupshown");
+    EventUtils.synthesizeMouseAtCenter(
+      tab,
+      { type: "contextmenu", button: 2 },
+      window
+    );
+    await shown;
+
+    let hidden = BrowserTestUtils.waitForEvent(context, "popuphidden");
+    context.activateItem(document.getElementById("context_toggleMuteTab"));
+    await hidden;
+
+    assertInteractionScalars({
+      tabs_context: {
+        "context-toggleMuteTab": 1,
+      },
+    });
+
+    // Check that tab-related items in the toolbar menu also register telemetry:
+    context = elem("toolbar-context-menu");
+    shown = BrowserTestUtils.waitForEvent(context, "popupshown");
+    let scrollbox = elem("tabbrowser-arrowscrollbox");
+    EventUtils.synthesizeMouse(
+      scrollbox,
+      // offset within the scrollbox - somewhere near the end:
+      scrollbox.getBoundingClientRect().width - 20,
+      5,
+      { type: "contextmenu", button: 2 },
+      window
+    );
+    await shown;
+
+    hidden = BrowserTestUtils.waitForEvent(context, "popuphidden");
+    context.activateItem(
+      document.getElementById("toolbar-context-selectAllTabs")
+    );
+    await hidden;
+
+    assertInteractionScalars({
+      tabs_context: {
+        "toolbar-context-selectAllTabs": 1,
+      },
+    });
+    // tidy up:
+    gBrowser.clearMultiSelectedTabs();
+  });
+});
+
+add_task(async function contextMenu_entrypoints() {
+  /**
+   * A utility function for this test task that opens the tab context
+   * menu for a particular trigger node, chooses the "Reload Tab" item,
+   * and then waits for the context menu to close.
+   *
+   * @param {Element} triggerNode
+   *   The node that the tab context menu should be triggered with.
+   * @returns {Promise<undefined>}
+   *   Resolves after the context menu has fired the popuphidden event.
+   */
+  let openAndCloseTabContextMenu = async triggerNode => {
+    let contextMenu = document.getElementById("tabContextMenu");
+    let popupShown = BrowserTestUtils.waitForEvent(contextMenu, "popupshown");
+    EventUtils.synthesizeMouseAtCenter(triggerNode, {
+      type: "contextmenu",
+      button: 2,
+    });
+    await popupShown;
+
+    let popupHidden = BrowserTestUtils.waitForEvent(contextMenu, "popuphidden");
+    let menuitem = document.getElementById("context_reloadTab");
+    contextMenu.activateItem(menuitem);
+    await popupHidden;
+  };
+
+  const TAB_CONTEXTMENU_ENTRYPOINT_SCALAR =
+    "browser.ui.interaction.tabs_context_entrypoint";
+  Services.telemetry.clearScalars();
+
+  let scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
+  TelemetryTestUtils.assertScalarUnset(
+    scalars,
+    TAB_CONTEXTMENU_ENTRYPOINT_SCALAR
+  );
+
+  await openAndCloseTabContextMenu(gBrowser.selectedTab);
+  scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
+  TelemetryTestUtils.assertKeyedScalar(
+    scalars,
+    TAB_CONTEXTMENU_ENTRYPOINT_SCALAR,
+    "tabs-bar",
+    1
+  );
+
+  gTabsPanel.initElements();
+  let allTabsView = document.getElementById("allTabsMenu-allTabsView");
+  let allTabsPopupShownPromise = BrowserTestUtils.waitForEvent(
+    allTabsView,
+    "ViewShown"
+  );
+  gTabsPanel.showAllTabsPanel(null);
+  await allTabsPopupShownPromise;
+
+  let firstTabItem = gTabsPanel.allTabsViewTabs.children[0];
+  await openAndCloseTabContextMenu(firstTabItem);
+  scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
+  TelemetryTestUtils.assertKeyedScalar(
+    scalars,
+    TAB_CONTEXTMENU_ENTRYPOINT_SCALAR,
+    "alltabs-menu",
+    1
+  );
+
+  let allTabsPopupHiddenPromise = BrowserTestUtils.waitForEvent(
+    allTabsView.panelMultiView,
+    "PanelMultiViewHidden"
+  );
+  gTabsPanel.hideAllTabsPanel();
+  await allTabsPopupHiddenPromise;
+});
+
+add_task(async function appMenu() {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popupshown"
+    );
+    click("PanelUI-menu-button");
+    await shown;
+
+    let hidden = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popuphidden"
+    );
+
+    let findButtonID = "appMenu-find-button2";
+    click(findButtonID);
+    await hidden;
+
+    let expectedScalars = {
+      nav_bar: {
+        "PanelUI-menu-button": 1,
+      },
+      app_menu: {},
+    };
+    expectedScalars.app_menu[findButtonID] = 1;
+
+    assertInteractionScalars(expectedScalars);
+  });
+});
+
+add_task(async function devtools() {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popupshown"
+    );
+    click("PanelUI-menu-button");
+    await shown;
+
+    click("appMenu-more-button2");
+    shown = BrowserTestUtils.waitForEvent(
+      elem("appmenu-moreTools"),
+      "ViewShown"
+    );
+    await shown;
+
+    let tabOpen = BrowserTestUtils.waitForNewTab(gBrowser);
+    let hidden = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popuphidden"
+    );
+    click(
+      document.querySelector(
+        "#appmenu-moreTools toolbarbutton[key='key_viewSource']"
+      )
+    );
+    await hidden;
+
+    let tab = await tabOpen;
+    BrowserTestUtils.removeTab(tab);
+
+    // Note that item ID's have '_' converted to '-'.
+    assertInteractionScalars({
+      nav_bar: {
+        "PanelUI-menu-button": 1,
+      },
+      app_menu: {
+        "appMenu-more-button2": 1,
+        "key-viewSource": 1,
+      },
+    });
+  });
+});
+
+add_task(async function webextension() {
+  BrowserUsageTelemetry._resetAddonIds();
+
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    function background() {
+      browser.commands.onCommand.addListener(() => {
+        browser.test.sendMessage("oncommand");
+      });
+
+      browser.runtime.onMessage.addListener(msg => {
+        if (msg == "from-sidebar-action") {
+          browser.test.sendMessage("sidebar-opened");
+        }
+      });
+
+      browser.test.sendMessage("ready");
+    }
+
+    const extension = ExtensionTestUtils.loadExtension({
+      manifest: {
+        version: "1",
+        browser_specific_settings: {
+          gecko: { id: "random_addon@example.com" },
+        },
+        browser_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+          default_area: "navbar",
+        },
+        page_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+          show_matches: ["https://example.com/*"],
+        },
+        commands: {
+          test_command: {
+            suggested_key: {
+              default: "Alt+Shift+J",
+            },
+          },
+          _execute_sidebar_action: {
+            suggested_key: {
+              default: "Alt+Shift+Q",
+            },
+          },
+        },
+        sidebar_action: {
+          default_panel: "sidebar.html",
+          open_at_install: false,
+        },
+      },
+      files: {
+        "sidebar.html": `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <script src="sidebar.js"></script>
+            </head>
+          </html>
+        `,
+
+        "sidebar.js": function () {
+          browser.runtime.sendMessage("from-sidebar-action");
+        },
+      },
+      background,
+    });
+
+    await extension.startup();
+    await extension.awaitMessage("ready");
+
+    // As the first add-on interacted with this should show up as `addon0`.
+
+    click("random_addon_example_com-browser-action");
+    assertInteractionScalars({
+      nav_bar: {
+        addon0: 1,
+      },
+    });
+
+    // Wait for the element to show up.
+    await TestUtils.waitForCondition(() =>
+      elem("pageAction-urlbar-random_addon_example_com")
+    );
+
+    click("pageAction-urlbar-random_addon_example_com");
+    assertInteractionScalars({
+      pageaction_urlbar: {
+        addon0: 1,
+      },
+    });
+
+    EventUtils.synthesizeKey("j", { altKey: true, shiftKey: true });
+    await extension.awaitMessage("oncommand");
+    assertInteractionScalars({
+      keyboard: {
+        addon0: 1,
+      },
+    });
+
+    EventUtils.synthesizeKey("q", { altKey: true, shiftKey: true });
+    await extension.awaitMessage("sidebar-opened");
+    assertInteractionScalars({
+      keyboard: {
+        addon0: 1,
+      },
+    });
+
+    const extension2 = ExtensionTestUtils.loadExtension({
+      manifest: {
+        version: "1",
+        browser_specific_settings: {
+          gecko: { id: "random_addon2@example.com" },
+        },
+        browser_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+          default_area: "navbar",
+        },
+        page_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+          show_matches: ["https://example.com/*"],
+        },
+        commands: {
+          test_command: {
+            suggested_key: {
+              default: "Alt+Shift+9",
+            },
+          },
+        },
+      },
+      background,
+    });
+
+    await extension2.startup();
+    await extension2.awaitMessage("ready");
+
+    // A second extension should be `addon1`.
+
+    click("random_addon2_example_com-browser-action");
+    assertInteractionScalars({
+      nav_bar: {
+        addon1: 1,
+      },
+    });
+
+    // Wait for the element to show up.
+    await TestUtils.waitForCondition(() =>
+      elem("pageAction-urlbar-random_addon2_example_com")
+    );
+
+    click("pageAction-urlbar-random_addon2_example_com");
+    assertInteractionScalars({
+      pageaction_urlbar: {
+        addon1: 1,
+      },
+    });
+
+    EventUtils.synthesizeKey("9", { altKey: true, shiftKey: true });
+    await extension2.awaitMessage("oncommand");
+    assertInteractionScalars({
+      keyboard: {
+        addon1: 1,
+      },
+    });
+
+    // The first should have retained its ID.
+    click("random_addon_example_com-browser-action");
+    assertInteractionScalars({
+      nav_bar: {
+        addon0: 1,
+      },
+    });
+
+    EventUtils.synthesizeKey("j", { altKey: true, shiftKey: true });
+    await extension.awaitMessage("oncommand");
+    assertInteractionScalars({
+      keyboard: {
+        addon0: 1,
+      },
+    });
+
+    click("pageAction-urlbar-random_addon_example_com");
+    assertInteractionScalars({
+      pageaction_urlbar: {
+        addon0: 1,
+      },
+    });
+
+    await extension.unload();
+
+    // Clear the last opened ID so if this test runs again the sidebar won't
+    // automatically open when the extension is installed.
+    window.SidebarUI.lastOpenedId = null;
+
+    // The second should retain its ID.
+    click("random_addon2_example_com-browser-action");
+    click("random_addon2_example_com-browser-action");
+    assertInteractionScalars({
+      nav_bar: {
+        addon1: 2,
+      },
+    });
+
+    click("pageAction-urlbar-random_addon2_example_com");
+    assertInteractionScalars({
+      pageaction_urlbar: {
+        addon1: 1,
+      },
+    });
+
+    EventUtils.synthesizeKey("9", { altKey: true, shiftKey: true });
+    await extension2.awaitMessage("oncommand");
+    assertInteractionScalars({
+      keyboard: {
+        addon1: 1,
+      },
+    });
+
+    await extension2.unload();
+
+    // Now test that browser action items in the add-ons panel also get
+    // telemetry recorded for them.
+    const extension3 = ExtensionTestUtils.loadExtension({
+      manifest: {
+        version: "1",
+        browser_specific_settings: {
+          gecko: { id: "random_addon3@example.com" },
+        },
+        browser_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+        },
+      },
+    });
+
+    await extension3.startup();
+
+    const shown = BrowserTestUtils.waitForPopupEvent(
+      gUnifiedExtensions.panel,
+      "shown"
+    );
+    await gUnifiedExtensions.togglePanel();
+    await shown;
+
+    click("random_addon3_example_com-browser-action");
+    assertInteractionScalars({
+      unified_extensions_area: {
+        addon2: 1,
+      },
+    });
+    const hidden = BrowserTestUtils.waitForPopupEvent(
+      gUnifiedExtensions.panel,
+      "hidden"
+    );
+    await gUnifiedExtensions.panel.hidePopup();
+    await hidden;
+
+    await extension3.unload();
+  });
+});
+
+add_task(async function mainMenu() {
+  // macOS does not use the menu bar.
+  if (AppConstants.platform == "macosx") {
+    return;
+  }
+
+  BrowserUsageTelemetry._resetAddonIds();
+
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    CustomizableUI.setToolbarVisibility("toolbar-menubar", true);
+
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("menu_EditPopup"),
+      "popupshown"
+    );
+    click("edit-menu");
+    await shown;
+
+    let hidden = BrowserTestUtils.waitForEvent(
+      elem("menu_EditPopup"),
+      "popuphidden"
+    );
+    click("menu_selectAll");
+    await hidden;
+
+    assertInteractionScalars({
+      menu_bar: {
+        // Note that the _ is replaced with - for telemetry identifiers.
+        "menu-selectAll": 1,
+      },
+    });
+
+    CustomizableUI.setToolbarVisibility("toolbar-menubar", false);
+  });
+});
+
+add_task(async function preferences() {
+  let finalPaneEvent = Services.prefs.getBoolPref("identity.fxaccounts.enabled")
+    ? "sync-pane-loaded"
+    : "privacy-pane-loaded";
+  let finalPrefPaneLoaded = TestUtils.topicObserved(finalPaneEvent, () => true);
+  await BrowserTestUtils.withNewTab("about:preferences", async browser => {
+    await finalPrefPaneLoaded;
+
+    Services.telemetry.getSnapshotForKeyedScalars("main", true);
+
+    await BrowserTestUtils.synthesizeMouseAtCenter(
+      "#browserRestoreSession",
+      {},
+      gBrowser.selectedBrowser.browsingContext
+    );
+
+    await BrowserTestUtils.synthesizeMouseAtCenter(
+      "#category-search",
+      {},
+      gBrowser.selectedBrowser.browsingContext
+    );
+
+    await BrowserTestUtils.synthesizeMouseAtCenter(
+      "#category-privacy",
+      {},
+      gBrowser.selectedBrowser.browsingContext
+    );
+    await BrowserTestUtils.waitForCondition(() =>
+      gBrowser.selectedBrowser.contentDocument.getElementById(
+        "contentBlockingLearnMore"
+      )
+    );
+
+    const onLearnMoreOpened = BrowserTestUtils.waitForNewTab(gBrowser);
+    gBrowser.selectedBrowser.contentDocument
+      .getElementById("contentBlockingLearnMore")
+      .scrollIntoView();
+    await BrowserTestUtils.synthesizeMouseAtCenter(
+      "#contentBlockingLearnMore",
+      {},
+      gBrowser.selectedBrowser.browsingContext
+    );
+    await onLearnMoreOpened;
+    gBrowser.removeCurrentTab();
+
+    assertInteractionScalars({
+      preferences_paneGeneral: {
+        browserRestoreSession: 1,
+      },
+      preferences_panePrivacy: {
+        contentBlockingLearnMore: 1,
+      },
+    });
+  });
+});
+
+/**
+ * Context click on a history or bookmark link and open it in a new window.
+ *
+ * @param {Element} link - The link to open.
+ */
+async function openLinkUsingContextMenu(link) {
+  const placesContext = document.getElementById("placesContext");
+  const promisePopup = BrowserTestUtils.waitForEvent(
+    placesContext,
+    "popupshown"
+  );
+  EventUtils.synthesizeMouseAtCenter(link, {
+    button: 2,
+    type: "contextmenu",
+  });
+  await promisePopup;
+  const promiseNewWindow = BrowserTestUtils.waitForNewWindow();
+  placesContext.activateItem(
+    document.getElementById("placesContext_open:newwindow")
+  );
+  const win = await promiseNewWindow;
+  await BrowserTestUtils.closeWindow(win);
+}
+
+async function history_appMenu(useContextClick) {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popupshown"
+    );
+    click("PanelUI-menu-button");
+    await shown;
+
+    click("appMenu-history-button");
+    shown = BrowserTestUtils.waitForEvent(elem("PanelUI-history"), "ViewShown");
+    await shown;
+
+    let list = document.getElementById("appMenu_historyMenu");
+    let listItem = list.querySelector("toolbarbutton");
+
+    if (useContextClick) {
+      await openLinkUsingContextMenu(listItem);
+    } else {
+      EventUtils.synthesizeMouseAtCenter(listItem, {});
+    }
+
+    let expectedScalars = {
+      nav_bar: {
+        "PanelUI-menu-button": 1,
+      },
+
+      app_menu: { "history-item": 1, "appMenu-history-button": 1 },
+    };
+    assertInteractionScalars(expectedScalars);
+  });
+}
+
+add_task(async function history_appMenu_click() {
+  await history_appMenu(false);
+});
+
+add_task(async function history_appMenu_context_click() {
+  await history_appMenu(true);
+});
+
+async function bookmarks_appMenu(useContextClick) {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("appMenu-popup"),
+      "popupshown"
+    );
+
+    shown = BrowserTestUtils.waitForEvent(elem("appMenu-popup"), "popupshown");
+    click("PanelUI-menu-button");
+    await shown;
+
+    click("appMenu-bookmarks-button");
+    shown = BrowserTestUtils.waitForEvent(
+      elem("PanelUI-bookmarks"),
+      "ViewShown"
+    );
+    await shown;
+
+    let list = document.getElementById("panelMenu_bookmarksMenu");
+    let listItem = list.querySelector("toolbarbutton");
+
+    if (useContextClick) {
+      await openLinkUsingContextMenu(listItem);
+    } else {
+      EventUtils.synthesizeMouseAtCenter(listItem, {});
+    }
+
+    let expectedScalars = {
+      nav_bar: {
+        "PanelUI-menu-button": 1,
+      },
+
+      app_menu: { "bookmark-item": 1, "appMenu-bookmarks-button": 1 },
+    };
+    assertInteractionScalars(expectedScalars);
+  });
+}
+
+add_task(async function bookmarks_appMenu_click() {
+  await bookmarks_appMenu(false);
+});
+
+add_task(async function bookmarks_appMenu_context_click() {
+  await bookmarks_appMenu(true);
+});
+
+async function bookmarks_library_navbar(useContextClick) {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    CustomizableUI.addWidgetToArea("library-button", "nav-bar");
+    let button = document.getElementById("library-button");
+    button.click();
+    await BrowserTestUtils.waitForEvent(
+      elem("appMenu-libraryView"),
+      "ViewShown"
+    );
+
+    click("appMenu-library-bookmarks-button");
+    await BrowserTestUtils.waitForEvent(elem("PanelUI-bookmarks"), "ViewShown");
+
+    let list = document.getElementById("panelMenu_bookmarksMenu");
+    let listItem = list.querySelector("toolbarbutton");
+
+    if (useContextClick) {
+      await openLinkUsingContextMenu(listItem);
+    } else {
+      EventUtils.synthesizeMouseAtCenter(listItem, {});
+    }
+
+    let expectedScalars = {
+      nav_bar: {
+        "library-button": 1,
+        "bookmark-item": 1,
+        "appMenu-library-bookmarks-button": 1,
+      },
+    };
+    assertInteractionScalars(expectedScalars);
+  });
+
+  CustomizableUI.removeWidgetFromArea("library-button");
+}
+
+add_task(async function bookmarks_library_navbar_click() {
+  await bookmarks_library_navbar(false);
+});
+
+add_task(async function bookmarks_library_navbar_context_click() {
+  await bookmarks_library_navbar(true);
+});
+
+async function history_library_navbar(useContextClick) {
+  await BrowserTestUtils.withNewTab("https://example.com", async browser => {
+    CustomizableUI.addWidgetToArea("library-button", "nav-bar");
+    let button = document.getElementById("library-button");
+    button.click();
+    await BrowserTestUtils.waitForEvent(
+      elem("appMenu-libraryView"),
+      "ViewShown"
+    );
+
+    click("appMenu-library-history-button");
+    let shown = BrowserTestUtils.waitForEvent(
+      elem("PanelUI-history"),
+      "ViewShown"
+    );
+    await shown;
+
+    let list = document.getElementById("appMenu_historyMenu");
+    let listItem = list.querySelector("toolbarbutton");
+
+    if (useContextClick) {
+      await openLinkUsingContextMenu(listItem);
+    } else {
+      EventUtils.synthesizeMouseAtCenter(listItem, {});
+    }
+
+    let expectedScalars = {
+      nav_bar: {
+        "library-button": 1,
+        "history-item": 1,
+        "appMenu-library-history-button": 1,
+      },
+    };
+    assertInteractionScalars(expectedScalars);
+  });
+
+  CustomizableUI.removeWidgetFromArea("library-button");
+}
+
+add_task(async function history_library_navbar_click() {
+  await history_library_navbar(false);
+});
+
+add_task(async function history_library_navbar_context_click() {
+  await history_library_navbar(true);
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_private_and_restore.js b/browser/modules/test/browser/browser_UsageTelemetry_private_and_restore.js
new file mode 100644
index 0000000000..89222739be
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_private_and_restore.js
@@ -0,0 +1,164 @@
+"use strict";
+
+const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL;
+
+const MAX_CONCURRENT_TABS = "browser.engagement.max_concurrent_tab_count";
+const TAB_EVENT_COUNT = "browser.engagement.tab_open_event_count";
+const MAX_CONCURRENT_WINDOWS = "browser.engagement.max_concurrent_window_count";
+const WINDOW_OPEN_COUNT = "browser.engagement.window_open_event_count";
+const TOTAL_URI_COUNT = "browser.engagement.total_uri_count";
+const UNFILTERED_URI_COUNT = "browser.engagement.unfiltered_uri_count";
+const UNIQUE_DOMAINS_COUNT = "browser.engagement.unique_domains_count";
+const TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE =
+  "browser.engagement.total_uri_count_normal_and_private_mode";
+
+BrowserUsageTelemetry._onTabsOpenedTask._timeoutMs = 0;
+registerCleanupFunction(() => {
+  BrowserUsageTelemetry._onTabsOpenedTask._timeoutMs = undefined;
+});
+
+function promiseBrowserStateRestored() {
+  return new Promise(resolve => {
+    Services.obs.addObserver(function observer(aSubject, aTopic) {
+      Services.obs.removeObserver(
+        observer,
+        "sessionstore-browser-state-restored"
+      );
+      resolve();
+    }, "sessionstore-browser-state-restored");
+  });
+}
+
+add_task(async function test_privateMode() {
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+  Services.fog.testResetFOG();
+
+  // Open a private window and load a website in it.
+  let privateWin = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  await BrowserTestUtils.firstBrowserLoaded(privateWin);
+  BrowserTestUtils.startLoadingURIString(
+    privateWin.gBrowser.selectedBrowser,
+    "https://example.com/"
+  );
+  await BrowserTestUtils.browserLoaded(
+    privateWin.gBrowser.selectedBrowser,
+    false,
+    "https://example.com/"
+  );
+
+  // Check that tab and window count is recorded.
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  ok(
+    !(TOTAL_URI_COUNT in scalars),
+    "We should not track URIs in private mode."
+  );
+  ok(
+    !(UNFILTERED_URI_COUNT in scalars),
+    "We should not track URIs in private mode."
+  );
+  ok(
+    !(UNIQUE_DOMAINS_COUNT in scalars),
+    "We should not track unique domains in private mode."
+  );
+  is(
+    scalars[TAB_EVENT_COUNT],
+    1,
+    "The number of open tab event count must match the expected value."
+  );
+  is(
+    scalars[MAX_CONCURRENT_TABS],
+    2,
+    "The maximum tab count must match the expected value."
+  );
+  is(
+    scalars[WINDOW_OPEN_COUNT],
+    1,
+    "The number of window open event count must match the expected value."
+  );
+  is(
+    scalars[MAX_CONCURRENT_WINDOWS],
+    2,
+    "The maximum window count must match the expected value."
+  );
+  is(
+    scalars[TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE],
+    1,
+    "We should include URIs in private mode as part of the actual total URI count."
+  );
+  is(
+    Glean.browserEngagement.uriCount.testGetValue(),
+    1,
+    "We should record the URI count in Glean as well."
+  );
+
+  // Clean up.
+  await BrowserTestUtils.closeWindow(privateWin);
+});
+
+add_task(async function test_sessionRestore() {
+  const PREF_RESTORE_ON_DEMAND = "browser.sessionstore.restore_on_demand";
+  Services.prefs.setBoolPref(PREF_RESTORE_ON_DEMAND, false);
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref(PREF_RESTORE_ON_DEMAND);
+  });
+
+  // Let's reset the counts.
+  Services.telemetry.clearScalars();
+
+  // The first window will be put into the already open window and the second
+  // window will be opened with _openWindowWithState, which is the source of the problem.
+  const state = {
+    windows: [
+      {
+        tabs: [
+          {
+            entries: [
+              { url: "http://example.org", triggeringPrincipal_base64 },
+            ],
+            extData: { uniq: 3785 },
+          },
+        ],
+        selected: 1,
+      },
+    ],
+  };
+
+  // Save the current session.
+  let { SessionStore } = ChromeUtils.importESModule(
+    "resource:///modules/sessionstore/SessionStore.sys.mjs"
+  );
+
+  // Load the custom state and wait for SSTabRestored, as we want to make sure
+  // that the URI counting code was hit.
+  let tabRestored = BrowserTestUtils.waitForEvent(
+    gBrowser.tabContainer,
+    "SSTabRestored"
+  );
+  SessionStore.setBrowserState(JSON.stringify(state));
+  await tabRestored;
+
+  // Check that the URI is not recorded.
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+
+  ok(
+    !(TOTAL_URI_COUNT in scalars),
+    "We should not track URIs from restored sessions."
+  );
+  ok(
+    !(UNFILTERED_URI_COUNT in scalars),
+    "We should not track URIs from restored sessions."
+  );
+  ok(
+    !(UNIQUE_DOMAINS_COUNT in scalars),
+    "We should not track unique domains from restored sessions."
+  );
+
+  // Restore the original session and cleanup.
+  let sessionRestored = promiseBrowserStateRestored();
+  SessionStore.setBrowserState(JSON.stringify(state));
+  await sessionRestored;
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_toolbars.js b/browser/modules/test/browser/browser_UsageTelemetry_toolbars.js
new file mode 100644
index 0000000000..aade03ec84
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_toolbars.js
@@ -0,0 +1,550 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+gReduceMotionOverride = true;
+
+function enterCustomizationMode(win = window) {
+  let customizationReadyPromise = BrowserTestUtils.waitForEvent(
+    win.gNavToolbox,
+    "customizationready"
+  );
+  win.gCustomizeMode.enter();
+  return customizationReadyPromise;
+}
+
+function leaveCustomizationMode(win = window) {
+  let customizationDonePromise = BrowserTestUtils.waitForEvent(
+    win.gNavToolbox,
+    "aftercustomization"
+  );
+  win.gCustomizeMode.exit();
+  return customizationDonePromise;
+}
+
+Services.prefs.setBoolPref("browser.uiCustomization.skipSourceNodeCheck", true);
+registerCleanupFunction(() => {
+  CustomizableUI.reset();
+  Services.prefs.clearUserPref("browser.uiCustomization.skipSourceNodeCheck");
+});
+
+// Stolen from browser/components/customizableui/tests/browser/head.js
+function simulateItemDrag(aToDrag, aTarget, aEvent = {}, aOffset = 2) {
+  let ev = aEvent;
+  if (ev == "end" || ev == "start") {
+    let win = aTarget.ownerGlobal;
+    const dwu = win.windowUtils;
+    let bounds = dwu.getBoundsWithoutFlushing(aTarget);
+    if (ev == "end") {
+      ev = {
+        clientX: bounds.right - aOffset,
+        clientY: bounds.bottom - aOffset,
+      };
+    } else {
+      ev = { clientX: bounds.left + aOffset, clientY: bounds.top + aOffset };
+    }
+  }
+  ev._domDispatchOnly = true;
+  EventUtils.synthesizeDrop(
+    aToDrag.parentNode,
+    aTarget,
+    null,
+    null,
+    aToDrag.ownerGlobal,
+    aTarget.ownerGlobal,
+    ev
+  );
+  // Ensure dnd suppression is cleared.
+  EventUtils.synthesizeMouseAtCenter(
+    aTarget,
+    { type: "mouseup" },
+    aTarget.ownerGlobal
+  );
+}
+
+function organizeToolbars(state = {}) {
+  // Set up the defaults for the state.
+  let targetState = Object.assign(
+    {
+      // Areas where widgets can be placed, set to an array of widget IDs.
+      "toolbar-menubar": undefined,
+      PersonalToolbar: undefined,
+      TabsToolbar: ["tabbrowser-tabs", "alltabs-button"],
+      "widget-overflow-fixed-list": undefined,
+      "nav-bar": ["back-button", "forward-button", "urlbar-container"],
+
+      // The page action's that should be in the URL bar.
+      pageActionsInUrlBar: [],
+
+      // Areas to show or hide.
+      titlebarVisible: false,
+      menubarVisible: false,
+      personalToolbarVisible: false,
+    },
+    state
+  );
+
+  for (let area of CustomizableUI.areas) {
+    // Clear out anything there already.
+    for (let widgetId of CustomizableUI.getWidgetIdsInArea(area)) {
+      CustomizableUI.removeWidgetFromArea(widgetId);
+    }
+
+    if (targetState[area]) {
+      // We specify the position explicitly to support the toolbars that have
+      // fixed widgets.
+      let position = 0;
+      for (let widgetId of targetState[area]) {
+        CustomizableUI.addWidgetToArea(widgetId, area, position++);
+      }
+    }
+  }
+
+  CustomizableUI.setToolbarVisibility(
+    "toolbar-menubar",
+    targetState.menubarVisible
+  );
+  CustomizableUI.setToolbarVisibility(
+    "PersonalToolbar",
+    targetState.personalToolbarVisible
+  );
+
+  Services.prefs.setIntPref(
+    "browser.tabs.inTitlebar",
+    !targetState.titlebarVisible
+  );
+
+  for (let action of PageActions.actions) {
+    action.pinnedToUrlbar = targetState.pageActionsInUrlBar.includes(action.id);
+  }
+
+  // Clear out the existing telemetry.
+  Services.telemetry.getSnapshotForKeyedScalars("main", true);
+}
+
+function assertVisibilityScalars(expected) {
+  let scalars =
+    Services.telemetry.getSnapshotForKeyedScalars("main", true)?.parent?.[
+      "browser.ui.toolbar_widgets"
+    ] ?? {};
+
+  // Only some platforms have the menubar items.
+  if (AppConstants.MENUBAR_CAN_AUTOHIDE) {
+    expected.push("menubar-items_pinned_menu-bar");
+  }
+
+  let keys = new Set(expected.concat(Object.keys(scalars)));
+  for (let key of keys) {
+    Assert.ok(expected.includes(key), `Scalar key ${key} was unexpected.`);
+    Assert.ok(scalars[key], `Expected to see see scalar key ${key} be true.`);
+  }
+}
+
+function assertCustomizeScalars(expected) {
+  let scalars =
+    Services.telemetry.getSnapshotForKeyedScalars("main", true)?.parent?.[
+      "browser.ui.customized_widgets"
+    ] ?? {};
+
+  let keys = new Set(Object.keys(expected).concat(Object.keys(scalars)));
+  for (let key of keys) {
+    Assert.equal(
+      scalars[key],
+      expected[key],
+      `Expected to see the correct value for scalar ${key}.`
+    );
+  }
+}
+
+add_task(async function widgetPositions() {
+  organizeToolbars();
+
+  BrowserUsageTelemetry._recordUITelemetry();
+
+  assertVisibilityScalars([
+    "menu-toolbar_pinned_off",
+    "titlebar_pinned_off",
+    "bookmarks-bar_pinned_off",
+
+    "tabbrowser-tabs_pinned_tabs-bar",
+    "alltabs-button_pinned_tabs-bar",
+    "unified-extensions-button_pinned_nav-bar-end",
+
+    "forward-button_pinned_nav-bar-start",
+    "back-button_pinned_nav-bar-start",
+  ]);
+
+  organizeToolbars({
+    PersonalToolbar: [
+      "fxa-toolbar-menu-button",
+      "new-tab-button",
+      "developer-button",
+    ],
+
+    TabsToolbar: [
+      "stop-reload-button",
+      "tabbrowser-tabs",
+      "personal-bookmarks",
+    ],
+
+    "nav-bar": [
+      "home-button",
+      "forward-button",
+      "downloads-button",
+      "urlbar-container",
+      "back-button",
+      "library-button",
+    ],
+
+    personalToolbarVisible: true,
+  });
+
+  BrowserUsageTelemetry._recordUITelemetry();
+
+  assertVisibilityScalars([
+    "menu-toolbar_pinned_off",
+    "titlebar_pinned_off",
+    "bookmarks-bar_pinned_on",
+
+    "tabbrowser-tabs_pinned_tabs-bar",
+    "stop-reload-button_pinned_tabs-bar",
+    "personal-bookmarks_pinned_tabs-bar",
+    "alltabs-button_pinned_tabs-bar",
+
+    "home-button_pinned_nav-bar-start",
+    "forward-button_pinned_nav-bar-start",
+    "downloads-button_pinned_nav-bar-start",
+    "back-button_pinned_nav-bar-end",
+    "library-button_pinned_nav-bar-end",
+    "unified-extensions-button_pinned_nav-bar-end",
+
+    "fxa-toolbar-menu-button_pinned_bookmarks-bar",
+    "new-tab-button_pinned_bookmarks-bar",
+    "developer-button_pinned_bookmarks-bar",
+  ]);
+
+  CustomizableUI.reset();
+});
+
+add_task(async function customizeMode() {
+  // Create a default state.
+  organizeToolbars({
+    PersonalToolbar: ["personal-bookmarks"],
+
+    TabsToolbar: ["tabbrowser-tabs", "new-tab-button"],
+
+    "nav-bar": [
+      "back-button",
+      "forward-button",
+      "stop-reload-button",
+      "urlbar-container",
+      "home-button",
+      "library-button",
+    ],
+  });
+
+  BrowserUsageTelemetry._recordUITelemetry();
+
+  assertVisibilityScalars([
+    "menu-toolbar_pinned_off",
+    "titlebar_pinned_off",
+    "bookmarks-bar_pinned_off",
+
+    "tabbrowser-tabs_pinned_tabs-bar",
+    "new-tab-button_pinned_tabs-bar",
+    "alltabs-button_pinned_tabs-bar",
+
+    "back-button_pinned_nav-bar-start",
+    "forward-button_pinned_nav-bar-start",
+    "stop-reload-button_pinned_nav-bar-start",
+    "home-button_pinned_nav-bar-end",
+    "library-button_pinned_nav-bar-end",
+    "unified-extensions-button_pinned_nav-bar-end",
+
+    "personal-bookmarks_pinned_bookmarks-bar",
+  ]);
+
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+
+  await enterCustomizationMode(win);
+
+  let toolbarButton = win.document.getElementById(
+    "customization-toolbar-visibility-button"
+  );
+  let toolbarPopup = win.document.getElementById("customization-toolbar-menu");
+  let popupShown = BrowserTestUtils.waitForEvent(toolbarPopup, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(toolbarButton, {}, win);
+  await popupShown;
+
+  let barMenu = win.document.getElementById("toggle_PersonalToolbar");
+  let popupHidden = BrowserTestUtils.waitForEvent(toolbarPopup, "popuphidden");
+  let subMenu = barMenu.querySelector("menupopup");
+  popupShown = BrowserTestUtils.waitForEvent(subMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(barMenu, {}, win);
+  await popupShown;
+  let alwaysButton = barMenu.querySelector('*[data-visibility-enum="always"]');
+  EventUtils.synthesizeMouseAtCenter(alwaysButton, {}, win);
+  await popupHidden;
+
+  let navbar = CustomizableUI.getCustomizationTarget(
+    win.document.getElementById("nav-bar")
+  );
+  let bookmarksBar = CustomizableUI.getCustomizationTarget(
+    win.document.getElementById("PersonalToolbar")
+  );
+  let tabBar = CustomizableUI.getCustomizationTarget(
+    win.document.getElementById("TabsToolbar")
+  );
+
+  simulateItemDrag(win.document.getElementById("home-button"), navbar, "start");
+  simulateItemDrag(win.document.getElementById("library-button"), bookmarksBar);
+  simulateItemDrag(win.document.getElementById("stop-reload-button"), tabBar);
+  simulateItemDrag(
+    win.document.getElementById("stop-reload-button"),
+    navbar,
+    "start"
+  );
+  simulateItemDrag(win.document.getElementById("stop-reload-button"), tabBar);
+
+  await leaveCustomizationMode(win);
+
+  await BrowserTestUtils.closeWindow(win);
+
+  assertCustomizeScalars({
+    "home-button_move_nav-bar-end_nav-bar-start_drag": 1,
+    "library-button_move_nav-bar-end_bookmarks-bar_drag": 1,
+    "stop-reload-button_move_nav-bar-start_tabs-bar_drag": 2,
+    "stop-reload-button_move_tabs-bar_nav-bar-start_drag": 1,
+    "bookmarks-bar_move_off_always_customization-toolbar-menu": 1,
+  });
+
+  CustomizableUI.reset();
+});
+
+add_task(async function contextMenus() {
+  // Create a default state.
+  organizeToolbars({
+    PersonalToolbar: ["personal-bookmarks"],
+
+    TabsToolbar: ["tabbrowser-tabs", "new-tab-button"],
+
+    "nav-bar": [
+      "back-button",
+      "forward-button",
+      "stop-reload-button",
+      "urlbar-container",
+      "home-button",
+      "library-button",
+    ],
+  });
+
+  BrowserUsageTelemetry._recordUITelemetry();
+
+  assertVisibilityScalars([
+    "menu-toolbar_pinned_off",
+    "titlebar_pinned_off",
+    "bookmarks-bar_pinned_off",
+
+    "tabbrowser-tabs_pinned_tabs-bar",
+    "new-tab-button_pinned_tabs-bar",
+    "alltabs-button_pinned_tabs-bar",
+
+    "back-button_pinned_nav-bar-start",
+    "forward-button_pinned_nav-bar-start",
+    "stop-reload-button_pinned_nav-bar-start",
+    "home-button_pinned_nav-bar-end",
+    "library-button_pinned_nav-bar-end",
+    "unified-extensions-button_pinned_nav-bar-end",
+
+    "personal-bookmarks_pinned_bookmarks-bar",
+  ]);
+
+  let menu = document.getElementById("toolbar-context-menu");
+  let popupShown = BrowserTestUtils.waitForEvent(menu, "popupshown");
+  let button = document.getElementById("stop-reload-button");
+  EventUtils.synthesizeMouseAtCenter(
+    button,
+    { type: "contextmenu", button: 2 },
+    window
+  );
+  await popupShown;
+
+  let barMenu = document.getElementById("toggle_PersonalToolbar");
+  let popupHidden = BrowserTestUtils.waitForEvent(menu, "popuphidden");
+  let subMenu = barMenu.querySelector("menupopup");
+  popupShown = BrowserTestUtils.waitForEvent(subMenu, "popupshown");
+  barMenu.openMenu(true);
+  await popupShown;
+  let alwaysButton = subMenu.querySelector('*[data-visibility-enum="always"]');
+  subMenu.activateItem(alwaysButton);
+  await popupHidden;
+
+  popupShown = BrowserTestUtils.waitForEvent(menu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(
+    button,
+    { type: "contextmenu", button: 2 },
+    window
+  );
+  await popupShown;
+
+  popupHidden = BrowserTestUtils.waitForEvent(menu, "popuphidden");
+  let removeButton = document.querySelector(
+    "#toolbar-context-menu .customize-context-removeFromToolbar"
+  );
+  menu.activateItem(removeButton);
+  await popupHidden;
+
+  assertCustomizeScalars({
+    "bookmarks-bar_move_off_always_toolbar-context-menu": 1,
+    "stop-reload-button_remove_nav-bar-start_na_toolbar-context-menu": 1,
+  });
+
+  CustomizableUI.reset();
+});
+
+add_task(async function extensions() {
+  // The page action button is only visible when a page is loaded.
+  await BrowserTestUtils.withNewTab("http://example.com", async () => {
+    organizeToolbars();
+
+    const extension = ExtensionTestUtils.loadExtension({
+      useAddonManager: "temporary",
+      manifest: {
+        version: "1",
+        browser_specific_settings: {
+          gecko: { id: "random_addon@example.com" },
+        },
+        browser_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+          default_area: "navbar",
+        },
+        page_action: {
+          default_icon: "default.png",
+          default_title: "Hello",
+        },
+      },
+    });
+
+    await extension.startup();
+
+    assertCustomizeScalars({
+      "random-addon-example-com_add_na_nav-bar-end_addon": 1,
+      "random-addon-example-com_add_na_pageaction-urlbar_addon": 1,
+    });
+
+    BrowserUsageTelemetry._recordUITelemetry();
+
+    assertVisibilityScalars([
+      "menu-toolbar_pinned_off",
+      "titlebar_pinned_off",
+      "bookmarks-bar_pinned_off",
+
+      "tabbrowser-tabs_pinned_tabs-bar",
+      "alltabs-button_pinned_tabs-bar",
+
+      "forward-button_pinned_nav-bar-start",
+      "back-button_pinned_nav-bar-start",
+
+      "random-addon-example-com_pinned_nav-bar-end",
+      "unified-extensions-button_pinned_nav-bar-end",
+
+      "random-addon-example-com_pinned_pageaction-urlbar",
+    ]);
+
+    let addon = await AddonManager.getAddonByID(extension.id);
+    await addon.disable();
+
+    assertCustomizeScalars({
+      "random-addon-example-com_remove_nav-bar-end_na_addon": 1,
+      "random-addon-example-com_remove_pageaction-urlbar_na_addon": 1,
+    });
+
+    BrowserUsageTelemetry._recordUITelemetry();
+
+    assertVisibilityScalars([
+      "menu-toolbar_pinned_off",
+      "titlebar_pinned_off",
+      "bookmarks-bar_pinned_off",
+
+      "tabbrowser-tabs_pinned_tabs-bar",
+      "alltabs-button_pinned_tabs-bar",
+
+      "forward-button_pinned_nav-bar-start",
+      "back-button_pinned_nav-bar-start",
+      "unified-extensions-button_pinned_nav-bar-end",
+    ]);
+
+    await addon.enable();
+
+    assertCustomizeScalars({
+      "random-addon-example-com_add_na_nav-bar-end_addon": 1,
+      "random-addon-example-com_add_na_pageaction-urlbar_addon": 1,
+    });
+
+    BrowserUsageTelemetry._recordUITelemetry();
+
+    assertVisibilityScalars([
+      "menu-toolbar_pinned_off",
+      "titlebar_pinned_off",
+      "bookmarks-bar_pinned_off",
+
+      "tabbrowser-tabs_pinned_tabs-bar",
+      "alltabs-button_pinned_tabs-bar",
+
+      "forward-button_pinned_nav-bar-start",
+      "back-button_pinned_nav-bar-start",
+
+      "random-addon-example-com_pinned_nav-bar-end",
+      "unified-extensions-button_pinned_nav-bar-end",
+
+      "random-addon-example-com_pinned_pageaction-urlbar",
+    ]);
+
+    await addon.reload();
+
+    assertCustomizeScalars({});
+
+    await enterCustomizationMode();
+
+    let navbar = CustomizableUI.getCustomizationTarget(
+      document.getElementById("nav-bar")
+    );
+
+    simulateItemDrag(
+      document.getElementById("random_addon_example_com-browser-action"),
+      navbar,
+      "start"
+    );
+
+    await leaveCustomizationMode();
+
+    assertCustomizeScalars({
+      "random-addon-example-com_move_nav-bar-end_nav-bar-start_drag": 1,
+    });
+
+    await extension.unload();
+
+    assertCustomizeScalars({
+      "random-addon-example-com_remove_nav-bar-start_na_addon": 1,
+      "random-addon-example-com_remove_pageaction-urlbar_na_addon": 1,
+    });
+
+    BrowserUsageTelemetry._recordUITelemetry();
+
+    assertVisibilityScalars([
+      "menu-toolbar_pinned_off",
+      "titlebar_pinned_off",
+      "bookmarks-bar_pinned_off",
+
+      "tabbrowser-tabs_pinned_tabs-bar",
+      "alltabs-button_pinned_tabs-bar",
+
+      "forward-button_pinned_nav-bar-start",
+      "back-button_pinned_nav-bar-start",
+      "unified-extensions-button_pinned_nav-bar-end",
+    ]);
+  });
+});
diff --git a/browser/modules/test/browser/browser_UsageTelemetry_uniqueOriginsVisitedInPast24Hours.js b/browser/modules/test/browser/browser_UsageTelemetry_uniqueOriginsVisitedInPast24Hours.js
new file mode 100644
index 0000000000..11986f8e31
--- /dev/null
+++ b/browser/modules/test/browser/browser_UsageTelemetry_uniqueOriginsVisitedInPast24Hours.js
@@ -0,0 +1,87 @@
+/* eslint-disable mozilla/no-arbitrary-setTimeout */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  URICountListener: "resource:///modules/BrowserUsageTelemetry.sys.mjs",
+});
+
+add_task(async function test_uniqueDomainsVisitedInPast24Hours() {
+  // By default, proxies don't apply to 127.0.0.1. We need them to for this test, though:
+  await SpecialPowers.pushPrefEnv({
+    set: [["network.proxy.allow_hijacking_localhost", true]],
+  });
+  registerCleanupFunction(async () => {
+    info("Cleaning up");
+    URICountListener.resetUniqueDomainsVisitedInPast24Hours();
+  });
+
+  URICountListener.resetUniqueDomainsVisitedInPast24Hours();
+  let startingCount = URICountListener.uniqueDomainsVisitedInPast24Hours;
+  is(
+    startingCount,
+    0,
+    "We should have no domains recorded in the history right after resetting"
+  );
+
+  // Add a new window and then some tabs in it.
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+  await BrowserTestUtils.openNewForegroundTab(
+    win.gBrowser,
+    "http://example.com"
+  );
+
+  await BrowserTestUtils.openNewForegroundTab(
+    win.gBrowser,
+    "http://test1.example.com"
+  );
+  is(
+    URICountListener.uniqueDomainsVisitedInPast24Hours,
+    startingCount + 1,
+    "test1.example.com should only count as a unique visit if example.com wasn't visited before"
+  );
+
+  await BrowserTestUtils.openNewForegroundTab(win.gBrowser, "http://127.0.0.1");
+  is(
+    URICountListener.uniqueDomainsVisitedInPast24Hours,
+    startingCount + 1,
+    "127.0.0.1 should not count as a unique visit"
+  );
+
+  // Set the expiry time to 4 seconds. The value should be reasonably short
+  // for testing, but long enough so that waiting for openNewForegroundTab
+  // does not cause the expiry timeout to run.
+  await SpecialPowers.pushPrefEnv({
+    set: [["browser.engagement.recent_visited_origins.expiry", 4]],
+  });
+
+  // http://www.exämple.test
+  await BrowserTestUtils.openNewForegroundTab(
+    win.gBrowser,
+    "http://xn--exmple-cua.test"
+  );
+  is(
+    URICountListener.uniqueDomainsVisitedInPast24Hours,
+    startingCount + 2,
+    "www.exämple.test should count as a unique visit"
+  );
+
+  let countBefore = URICountListener.uniqueDomainsVisitedInPast24Hours;
+
+  // If expiration does not work correctly, the following will time out.
+  await BrowserTestUtils.waitForCondition(() => {
+    return (
+      URICountListener.uniqueDomainsVisitedInPast24Hours == countBefore - 1
+    );
+  }, 250);
+
+  let countAfter = URICountListener.uniqueDomainsVisitedInPast24Hours;
+  is(countAfter, countBefore - 1, "The expiry should work correctly");
+
+  BrowserTestUtils.removeTab(win.gBrowser.selectedTab);
+  BrowserTestUtils.removeTab(win.gBrowser.selectedTab);
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/browser/modules/test/browser/browser_preloading_tab_moving.js b/browser/modules/test/browser/browser_preloading_tab_moving.js
new file mode 100644
index 0000000000..ce7cba9e85
--- /dev/null
+++ b/browser/modules/test/browser/browser_preloading_tab_moving.js
@@ -0,0 +1,150 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+var gOldCount = NewTabPagePreloading.MAX_COUNT;
+registerCleanupFunction(() => {
+  NewTabPagePreloading.MAX_COUNT = gOldCount;
+});
+
+async function openWinWithPreloadBrowser(options = {}) {
+  let idleFinishedPromise = TestUtils.topicObserved(
+    "browser-idle-startup-tasks-finished",
+    w => {
+      return w != window;
+    }
+  );
+  let newWin = await BrowserTestUtils.openNewBrowserWindow(options);
+  await idleFinishedPromise;
+  await TestUtils.waitForCondition(() => newWin.gBrowser.preloadedBrowser);
+  return newWin;
+}
+
+async function promiseNewTabLoadedInBrowser(browser) {
+  let url = browser.ownerGlobal.BROWSER_NEW_TAB_URL;
+  if (browser.currentURI.spec != url) {
+    info(`Waiting for ${url} to be the location for the browser.`);
+    await new Promise(resolve => {
+      let progressListener = {
+        onLocationChange(aWebProgress, aRequest, aLocationURI, aFlags) {
+          if (!url || aLocationURI.spec == url) {
+            browser.removeProgressListener(progressListener);
+            resolve();
+          }
+        },
+        QueryInterface: ChromeUtils.generateQI([
+          Ci.nsISupportsWeakReference,
+          Ci.nsIWebProgressListener2,
+          Ci.nsIWebProgressListener,
+        ]),
+      };
+      browser.addProgressListener(
+        progressListener,
+        Ci.nsIWebProgress.NOTIFY_ALL
+      );
+    });
+  } else {
+    info(`${url} already the current URI for the browser.`);
+  }
+
+  info(`Waiting for readyState complete in the browser`);
+  await SpecialPowers.spawn(browser, [], function () {
+    return ContentTaskUtils.waitForCondition(() => {
+      return content.document.readyState == "complete";
+    });
+  });
+}
+
+/**
+ * Verify that moving a preloaded browser's content from one window to the next
+ * works correctly.
+ */
+add_task(async function moving_works() {
+  NewTabPagePreloading.MAX_COUNT = 1;
+
+  NewTabPagePreloading.removePreloadedBrowser(window);
+
+  NewTabPagePreloading.maybeCreatePreloadedBrowser(window);
+  isnot(gBrowser.preloadedBrowser, null, "Should have preloaded browser");
+
+  let oldKey = gBrowser.preloadedBrowser.permanentKey;
+
+  let newWin = await openWinWithPreloadBrowser();
+  is(gBrowser.preloadedBrowser, null, "Preloaded browser should be gone");
+  isnot(
+    newWin.gBrowser.preloadedBrowser,
+    null,
+    "Should have moved the preload browser"
+  );
+  is(
+    newWin.gBrowser.preloadedBrowser.permanentKey,
+    oldKey,
+    "Should have the same permanent key"
+  );
+  let browser = newWin.gBrowser.preloadedBrowser;
+  let tab = BrowserTestUtils.addTab(
+    newWin.gBrowser,
+    newWin.BROWSER_NEW_TAB_URL
+  );
+  is(
+    tab.linkedBrowser,
+    browser,
+    "Preloaded browser is usable when opening a new tab."
+  );
+  await promiseNewTabLoadedInBrowser(browser);
+  ok(true, "Successfully loaded the tab.");
+
+  tab = browser = null;
+  await BrowserTestUtils.closeWindow(newWin);
+
+  tab = BrowserTestUtils.addTab(gBrowser, BROWSER_NEW_TAB_URL);
+  await promiseNewTabLoadedInBrowser(tab.linkedBrowser);
+
+  ok(true, "Managed to open a tab in the original window still.");
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function moving_shouldnt_move_across_private_state() {
+  NewTabPagePreloading.MAX_COUNT = 1;
+
+  NewTabPagePreloading.removePreloadedBrowser(window);
+
+  NewTabPagePreloading.maybeCreatePreloadedBrowser(window);
+  isnot(gBrowser.preloadedBrowser, null, "Should have preloaded browser");
+
+  let oldKey = gBrowser.preloadedBrowser.permanentKey;
+  let newWin = await openWinWithPreloadBrowser({ private: true });
+
+  isnot(
+    gBrowser.preloadedBrowser,
+    null,
+    "Preloaded browser in original window should persist"
+  );
+  isnot(
+    newWin.gBrowser.preloadedBrowser,
+    null,
+    "Should have created another preload browser"
+  );
+  isnot(
+    newWin.gBrowser.preloadedBrowser.permanentKey,
+    oldKey,
+    "Should not have the same permanent key"
+  );
+  let browser = newWin.gBrowser.preloadedBrowser;
+  let tab = BrowserTestUtils.addTab(
+    newWin.gBrowser,
+    newWin.BROWSER_NEW_TAB_URL
+  );
+  is(
+    tab.linkedBrowser,
+    browser,
+    "Preloaded browser is usable when opening a new tab."
+  );
+  await promiseNewTabLoadedInBrowser(browser);
+  ok(true, "Successfully loaded the tab.");
+
+  tab = browser = null;
+  await BrowserTestUtils.closeWindow(newWin);
+});
diff --git a/browser/modules/test/browser/browser_taskbar_preview.js b/browser/modules/test/browser/browser_taskbar_preview.js
new file mode 100644
index 0000000000..921a9eb1bc
--- /dev/null
+++ b/browser/modules/test/browser/browser_taskbar_preview.js
@@ -0,0 +1,129 @@
+function test() {
+  var isWin7OrHigher = false;
+  try {
+    let version = Services.sysinfo.getProperty("version");
+    isWin7OrHigher = parseFloat(version) >= 6.1;
+  } catch (ex) {}
+
+  is(
+    !!Win7Features,
+    isWin7OrHigher,
+    "Win7Features available when it should be"
+  );
+  if (!isWin7OrHigher) {
+    return;
+  }
+
+  const ENABLE_PREF_NAME = "browser.taskbar.previews.enable";
+
+  let { AeroPeek } = ChromeUtils.importESModule(
+    "resource:///modules/WindowsPreviewPerTab.sys.mjs"
+  );
+
+  waitForExplicitFinish();
+
+  Services.prefs.setBoolPref(ENABLE_PREF_NAME, true);
+
+  is(1, AeroPeek.windows.length, "Got the expected number of windows");
+
+  checkPreviews(1, "Browser starts with one preview");
+
+  BrowserTestUtils.addTab(gBrowser);
+  BrowserTestUtils.addTab(gBrowser);
+  BrowserTestUtils.addTab(gBrowser);
+
+  checkPreviews(4, "Correct number of previews after adding");
+
+  for (let preview of AeroPeek.previews) {
+    ok(preview.visible, "Preview is shown as expected");
+  }
+
+  Services.prefs.setBoolPref(ENABLE_PREF_NAME, false);
+  is(0, AeroPeek.previews.length, "Should have 0 previews when disabled");
+
+  Services.prefs.setBoolPref(ENABLE_PREF_NAME, true);
+  checkPreviews(4, "Previews are back when re-enabling");
+  for (let preview of AeroPeek.previews) {
+    ok(preview.visible, "Preview is shown as expected after re-enabling");
+  }
+
+  [1, 2, 3, 4].forEach(function (idx) {
+    gBrowser.selectedTab = gBrowser.tabs[idx];
+    ok(checkSelectedTab(), "Current tab is correctly selected");
+  });
+
+  // Close #4
+  getPreviewForTab(gBrowser.selectedTab).controller.onClose();
+  checkPreviews(
+    3,
+    "Expected number of previews after closing selected tab via controller"
+  );
+  Assert.equal(gBrowser.tabs.length, 3, "Successfully closed a tab");
+
+  // Select #1
+  ok(
+    getPreviewForTab(gBrowser.tabs[0]).controller.onActivate(),
+    "Activation was accepted"
+  );
+  ok(gBrowser.tabs[0].selected, "Correct tab was selected");
+  checkSelectedTab();
+
+  // Remove #3 (non active)
+  gBrowser.removeTab(gBrowser.tabs[gBrowser.tabs.length - 1]);
+  checkPreviews(
+    2,
+    "Expected number of previews after closing unselected via browser"
+  );
+
+  // Remove #1 (active)
+  gBrowser.removeTab(gBrowser.tabs[0]);
+  checkPreviews(
+    1,
+    "Expected number of previews after closing selected tab via browser"
+  );
+
+  // Add a new tab
+  BrowserTestUtils.addTab(gBrowser);
+  checkPreviews(2);
+  // Check default selection
+  checkSelectedTab();
+
+  // Change selection
+  gBrowser.selectedTab = gBrowser.tabs[0];
+  checkSelectedTab();
+  // Close nonselected tab via controller
+  getPreviewForTab(gBrowser.tabs[1]).controller.onClose();
+  checkPreviews(1);
+
+  if (Services.prefs.prefHasUserValue(ENABLE_PREF_NAME)) {
+    Services.prefs.setBoolPref(
+      ENABLE_PREF_NAME,
+      !Services.prefs.getBoolPref(ENABLE_PREF_NAME)
+    );
+  }
+
+  finish();
+
+  function checkPreviews(aPreviews, msg) {
+    let nPreviews = AeroPeek.previews.length;
+    is(
+      aPreviews,
+      gBrowser.tabs.length,
+      "Browser has expected number of tabs - " + msg
+    );
+    is(
+      nPreviews,
+      gBrowser.tabs.length,
+      "Browser has one preview per tab - " + msg
+    );
+    is(nPreviews, aPreviews, msg || "Got expected number of previews");
+  }
+
+  function getPreviewForTab(tab) {
+    return window.gTaskbarTabGroup.previewFromTab(tab);
+  }
+
+  function checkSelectedTab() {
+    return getPreviewForTab(gBrowser.selectedTab).active;
+  }
+}
diff --git a/browser/modules/test/browser/browser_urlBar_zoom.js b/browser/modules/test/browser/browser_urlBar_zoom.js
new file mode 100644
index 0000000000..21d8202a52
--- /dev/null
+++ b/browser/modules/test/browser/browser_urlBar_zoom.js
@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+var initialPageZoom = ZoomManager.zoom;
+const kTimeoutInMS = 20000;
+
+async function testZoomButtonAppearsAndDisappearsBasedOnZoomChanges(
+  zoomEventType
+) {
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    opening: "https://example.com/",
+    waitForStateStop: true,
+  });
+
+  info("Running this test with " + zoomEventType.substring(0, 9));
+  info("Confirm whether the browser zoom is set to the default level");
+  is(initialPageZoom, 1, "Page zoom is set to default (100%)");
+  let zoomResetButton = document.getElementById("urlbar-zoom-button");
+  is(zoomResetButton.hidden, true, "Zoom reset button is currently hidden");
+
+  info("Change zoom and confirm zoom button appears");
+  let labelUpdatePromise = BrowserTestUtils.waitForAttribute(
+    "label",
+    zoomResetButton
+  );
+  FullZoom.enlarge();
+  await labelUpdatePromise;
+  info("Zoom increased to " + Math.floor(ZoomManager.zoom * 100) + "%");
+  is(zoomResetButton.hidden, false, "Zoom reset button is now visible");
+  let pageZoomLevel = Math.floor(ZoomManager.zoom * 100);
+  let expectedZoomLevel = 110;
+  let buttonZoomLevel = parseInt(zoomResetButton.getAttribute("label"), 10);
+  is(
+    buttonZoomLevel,
+    expectedZoomLevel,
+    "Button label updated successfully to " +
+      Math.floor(ZoomManager.zoom * 100) +
+      "%"
+  );
+
+  let zoomResetPromise = BrowserTestUtils.waitForEvent(window, zoomEventType);
+  zoomResetButton.click();
+  await zoomResetPromise;
+  pageZoomLevel = Math.floor(ZoomManager.zoom * 100);
+  expectedZoomLevel = 100;
+  is(
+    pageZoomLevel,
+    expectedZoomLevel,
+    "Clicking zoom button successfully resets browser zoom to 100%"
+  );
+  is(zoomResetButton.hidden, true, "Zoom reset button returns to being hidden");
+
+  BrowserTestUtils.removeTab(tab);
+}
+
+add_task(async function () {
+  await testZoomButtonAppearsAndDisappearsBasedOnZoomChanges("FullZoomChange");
+  await SpecialPowers.pushPrefEnv({ set: [["browser.zoom.full", false]] });
+  await testZoomButtonAppearsAndDisappearsBasedOnZoomChanges("TextZoomChange");
+  await SpecialPowers.pushPrefEnv({ set: [["browser.zoom.full", true]] });
+});
+
+add_task(async function () {
+  info(
+    "Confirm that URL bar zoom button doesn't appear when customizable zoom widget is added to toolbar"
+  );
+  CustomizableUI.addWidgetToArea("zoom-controls", CustomizableUI.AREA_NAVBAR);
+  let zoomCustomizableWidget = document.getElementById("zoom-reset-button");
+  let zoomResetButton = document.getElementById("urlbar-zoom-button");
+  let zoomChangePromise = BrowserTestUtils.waitForEvent(
+    window,
+    "FullZoomChange"
+  );
+  FullZoom.enlarge();
+  await zoomChangePromise;
+  is(
+    zoomResetButton.hidden,
+    true,
+    "URL zoom button remains hidden despite zoom increase"
+  );
+  is(
+    parseInt(zoomCustomizableWidget.label, 10),
+    110,
+    "Customizable zoom widget's label has updated to " +
+      zoomCustomizableWidget.label
+  );
+});
+
+add_task(async function asyncCleanup() {
+  // reset zoom level and customizable widget
+  ZoomManager.zoom = initialPageZoom;
+  is(ZoomManager.zoom, 1, "Zoom level was restored");
+  if (document.getElementById("zoom-controls")) {
+    CustomizableUI.removeWidgetFromArea(
+      "zoom-controls",
+      CustomizableUI.AREA_NAVBAR
+    );
+    ok(
+      !document.getElementById("zoom-controls"),
+      "Customizable zoom widget removed from toolbar"
+    );
+  }
+});
diff --git a/browser/modules/test/browser/contain_iframe.html b/browser/modules/test/browser/contain_iframe.html
new file mode 100644
index 0000000000..8cea71fae4
--- /dev/null
+++ b/browser/modules/test/browser/contain_iframe.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8"/>
+  </head>
+  <body><iframe src="http://example.com"></iframe></body>
+</html>
diff --git a/browser/modules/test/browser/file_webrtc.html b/browser/modules/test/browser/file_webrtc.html
new file mode 100644
index 0000000000..1c75f7c75b
--- /dev/null
+++ b/browser/modules/test/browser/file_webrtc.html
@@ -0,0 +1,11 @@
+<html>
+<body onload="start()">
+<script>
+let stream;
+async function start()
+{
+  stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: true })
+}
+</script>
+</body>
+</html>
diff --git a/browser/modules/test/browser/formValidation/browser.toml b/browser/modules/test/browser/formValidation/browser.toml
new file mode 100644
index 0000000000..c7106c356b
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser.toml
@@ -0,0 +1,13 @@
+[DEFAULT]
+
+["browser_form_validation.js"]
+skip-if = ["true"] # bug 1057615
+
+["browser_validation_iframe.js"]
+skip-if = ["true"] # bug 1057615
+
+["browser_validation_invisible.js"]
+
+["browser_validation_navigation.js"]
+
+["browser_validation_other_popups.js"]
diff --git a/browser/modules/test/browser/formValidation/browser_form_validation.js b/browser/modules/test/browser/formValidation/browser_form_validation.js
new file mode 100644
index 0000000000..6348546c80
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser_form_validation.js
@@ -0,0 +1,522 @@
+/**
+ * COPIED FROM browser/base/content/test/general/head.js.
+ * This function should be removed and replaced with BTU withNewTab calls
+ *
+ * Waits for a load (or custom) event to finish in a given tab. If provided
+ * load an uri into the tab.
+ *
+ * @param tab
+ *        The tab to load into.
+ * @param [optional] url
+ *        The url to load, or the current url.
+ * @return {Promise} resolved when the event is handled.
+ * @resolves to the received event
+ * @rejects if a valid load event is not received within a meaningful interval
+ */
+function promiseTabLoadEvent(tab, url) {
+  info("Wait tab event: load");
+
+  function handle(loadedUrl) {
+    if (loadedUrl === "about:blank" || (url && loadedUrl !== url)) {
+      info(`Skipping spurious load event for ${loadedUrl}`);
+      return false;
+    }
+
+    info("Tab event received: load");
+    return true;
+  }
+
+  let loaded = BrowserTestUtils.browserLoaded(tab.linkedBrowser, false, handle);
+
+  if (url) {
+    BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, url);
+  }
+
+  return loaded;
+}
+
+var gInvalidFormPopup =
+  gBrowser.selectedBrowser.browsingContext.currentWindowGlobal
+    .getActor("FormValidation")
+    ._getAndMaybeCreatePanel(document);
+ok(
+  gInvalidFormPopup,
+  "The browser should have a popup to show when a form is invalid"
+);
+
+function isWithinHalfPixel(a, b) {
+  return Math.abs(a - b) <= 0.5;
+}
+
+function checkPopupShow(anchorRect) {
+  ok(
+    gInvalidFormPopup.state == "showing" || gInvalidFormPopup.state == "open",
+    "[Test " + testId + "] The invalid form popup should be shown"
+  );
+  // Just check the vertical position, as the horizontal position of an
+  // arrow panel will be offset.
+  is(
+    isWithinHalfPixel(gInvalidFormPopup.screenY),
+    isWithinHalfPixel(anchorRect.bottom),
+    "popup top"
+  );
+}
+
+function checkPopupHide() {
+  ok(
+    gInvalidFormPopup.state != "showing" && gInvalidFormPopup.state != "open",
+    "[Test " + testId + "] The invalid form popup should not be shown"
+  );
+}
+
+var testId = 0;
+
+function incrementTest() {
+  testId++;
+  info("Starting next part of test");
+}
+
+function getDocHeader() {
+  return "<html><head><meta charset='utf-8'></head><body>" + getEmptyFrame();
+}
+
+function getDocFooter() {
+  return "</body></html>";
+}
+
+function getEmptyFrame() {
+  return (
+    "<iframe style='width:100px; height:30px; margin:3px; border:1px solid lightgray;' " +
+    "name='t' srcdoc=\"<html><head><meta charset='utf-8'></head><body>form target</body></html>\"></iframe>"
+  );
+}
+
+async function openNewTab(uri, background) {
+  let tab = BrowserTestUtils.addTab(gBrowser);
+  let browser = gBrowser.getBrowserForTab(tab);
+  if (!background) {
+    gBrowser.selectedTab = tab;
+  }
+  await promiseTabLoadEvent(tab, "data:text/html," + escape(uri));
+  return browser;
+}
+
+function clickChildElement(browser) {
+  return SpecialPowers.spawn(browser, [], async function () {
+    let element = content.document.getElementById("s");
+    element.click();
+    return {
+      bottom: content.mozInnerScreenY + element.getBoundingClientRect().bottom,
+    };
+  });
+}
+
+async function blurChildElement(browser) {
+  await SpecialPowers.spawn(browser, [], async function () {
+    content.document.getElementById("i").blur();
+  });
+}
+
+async function checkChildFocus(browser, message) {
+  await SpecialPowers.spawn(
+    browser,
+    [[message, testId]],
+    async function (args) {
+      let [msg, id] = args;
+      var focused =
+        content.document.activeElement == content.document.getElementById("i");
+
+      var validMsg = true;
+      if (msg) {
+        validMsg =
+          msg == content.document.getElementById("i").validationMessage;
+      }
+
+      Assert.equal(
+        focused,
+        true,
+        "Test " + id + " First invalid element should be focused"
+      );
+      Assert.equal(
+        validMsg,
+        true,
+        "Test " +
+          id +
+          " The panel should show the message from validationMessage"
+      );
+    }
+  );
+}
+
+/**
+ * In this test, we check that no popup appears if the form is valid.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  await clickChildElement(browser);
+
+  await new Promise((resolve, reject) => {
+    // XXXndeakin This isn't really going to work when the content is another process
+    executeSoon(function () {
+      checkPopupHide();
+      resolve();
+    });
+  });
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that, when an invalid form is submitted,
+ * the invalid element is focused and a popup appears.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input required id='i'><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that, when an invalid form is submitted,
+ * the first invalid element is focused and a popup appears.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input><input id='i' required><input required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that, we hide the popup by interacting with the
+ * invalid element if the element becomes valid.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+  EventUtils.sendString("a");
+  await popupHiddenPromise;
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that, we don't hide the popup by interacting with the
+ * invalid element if the element is still invalid.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input type='email' id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  await new Promise((resolve, reject) => {
+    EventUtils.sendString("a");
+    executeSoon(function () {
+      checkPopupShow(anchorRect);
+      resolve();
+    });
+  });
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that we can hide the popup by blurring the invalid
+ * element.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+  await blurChildElement(browser);
+  await popupHiddenPromise;
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that we can hide the popup by pressing TAB.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+  EventUtils.synthesizeKey("KEY_Tab");
+  await popupHiddenPromise;
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that the popup will hide if we move to another tab.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser1 = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser1);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser1,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+
+  let browser2 = await openNewTab("data:text/html,<html></html>");
+  await popupHiddenPromise;
+
+  gBrowser.removeTab(gBrowser.getTabForBrowser(browser1));
+  gBrowser.removeTab(gBrowser.getTabForBrowser(browser2));
+});
+
+/**
+ * In this test, we check that the popup will hide if we navigate to another
+ * page.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+  BrowserTestUtils.startLoadingURIString(
+    browser,
+    "data:text/html,<div>hello!</div>"
+  );
+  await BrowserTestUtils.browserLoaded(browser);
+
+  await popupHiddenPromise;
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we check that the message is correctly updated when it changes.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input type='email' required id='i'><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let inputPromise = BrowserTestUtils.waitForContentEvent(browser, "input");
+  EventUtils.sendString("f");
+  await inputPromise;
+
+  // Now, the element suffers from another error, the message should have
+  // been updated.
+  await new Promise((resolve, reject) => {
+    // XXXndeakin This isn't really going to work when the content is another process
+    executeSoon(function () {
+      checkChildFocus(browser, gInvalidFormPopup.firstElementChild.textContent);
+      resolve();
+    });
+  });
+
+  gBrowser.removeCurrentTab();
+});
+
+/**
+ * In this test, we reload the page while the form validation popup is visible. The validation
+ * popup should hide.
+ */
+add_task(async function () {
+  incrementTest();
+  let uri =
+    getDocHeader() +
+    "<form target='t' action='data:text/html,'><input id='i' required><input id='s' type='submit'></form>" +
+    getDocFooter();
+  let browser = await openNewTab(uri);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popupshown"
+  );
+  let anchorRect = await clickChildElement(browser);
+  await popupShownPromise;
+
+  checkPopupShow(anchorRect);
+  await checkChildFocus(
+    browser,
+    gInvalidFormPopup.firstElementChild.textContent
+  );
+
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    gInvalidFormPopup,
+    "popuphidden"
+  );
+  BrowserReloadSkipCache();
+  await popupHiddenPromise;
+
+  gBrowser.removeCurrentTab();
+});
diff --git a/browser/modules/test/browser/formValidation/browser_validation_iframe.js b/browser/modules/test/browser/formValidation/browser_validation_iframe.js
new file mode 100644
index 0000000000..454c972f32
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser_validation_iframe.js
@@ -0,0 +1,67 @@
+/**
+ * Make sure that the form validation error message shows even if the form is in an iframe.
+ */
+add_task(async function test_iframe() {
+  let uri =
+    "data:text/html;charset=utf-8," +
+    escape(
+      "<iframe src=\"data:text/html,<iframe name='t'></iframe><form target='t' action='data:text/html,'><input required id='i'><input id='s' type='submit'></form>\" height=\"600\"></iframe>"
+    );
+
+  var gInvalidFormPopup =
+    gBrowser.selectedBrowser.browsingContext.currentWindowGlobal
+      .getActor("FormValidation")
+      ._getAndMaybeCreatePanel(document);
+  ok(
+    gInvalidFormPopup,
+    "The browser should have a popup to show when a form is invalid"
+  );
+
+  await BrowserTestUtils.withNewTab(uri, async function checkTab(browser) {
+    let popupShownPromise = BrowserTestUtils.waitForEvent(
+      gInvalidFormPopup,
+      "popupshown"
+    );
+
+    await SpecialPowers.spawn(browser, [], async function () {
+      content.document
+        .getElementsByTagName("iframe")[0]
+        .contentDocument.getElementById("s")
+        .click();
+    });
+    await popupShownPromise;
+
+    let anchorBottom = await SpecialPowers.spawn(
+      browser,
+      [],
+      async function () {
+        let childdoc =
+          content.document.getElementsByTagName("iframe")[0].contentDocument;
+        Assert.equal(
+          childdoc.activeElement,
+          childdoc.getElementById("i"),
+          "First invalid element should be focused"
+        );
+        return (
+          childdoc.defaultView.mozInnerScreenY +
+          childdoc.getElementById("i").getBoundingClientRect().bottom
+        );
+      }
+    );
+
+    function isWithinHalfPixel(a, b) {
+      return Math.abs(a - b) <= 0.5;
+    }
+
+    is(
+      isWithinHalfPixel(gInvalidFormPopup.screenY),
+      isWithinHalfPixel(anchorBottom),
+      "popup top"
+    );
+
+    ok(
+      gInvalidFormPopup.state == "showing" || gInvalidFormPopup.state == "open",
+      "The invalid form popup should be shown"
+    );
+  });
+});
diff --git a/browser/modules/test/browser/formValidation/browser_validation_invisible.js b/browser/modules/test/browser/formValidation/browser_validation_invisible.js
new file mode 100644
index 0000000000..9383ad773b
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser_validation_invisible.js
@@ -0,0 +1,67 @@
+"use strict";
+
+var gInvalidFormPopup =
+  gBrowser.selectedBrowser.browsingContext.currentWindowGlobal
+    .getActor("FormValidation")
+    ._getAndMaybeCreatePanel(document);
+
+function checkPopupHide() {
+  ok(
+    gInvalidFormPopup.state != "showing" && gInvalidFormPopup.state != "open",
+    "[Test " + testId + "] The invalid form popup should not be shown"
+  );
+}
+
+var testId = 0;
+
+function incrementTest() {
+  testId++;
+  info("Starting next part of test");
+}
+
+/**
+ * In this test, we check that no popup appears if the element display is none.
+ */
+add_task(async function test_display_none() {
+  ok(
+    gInvalidFormPopup,
+    "The browser should have a popup to show when a form is invalid"
+  );
+
+  incrementTest();
+  let testPage =
+    "data:text/html;charset=utf-8," +
+    '<form target="t"><input type="url"  placeholder="url" value="http://" style="display: none;"><input id="s" type="button" value="check"></form>';
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, testPage);
+  await BrowserTestUtils.synthesizeMouse(
+    "#s",
+    0,
+    0,
+    {},
+    gBrowser.selectedBrowser
+  );
+
+  checkPopupHide();
+  BrowserTestUtils.removeTab(tab);
+});
+
+/**
+ * In this test, we check that no popup appears if the element visibility is hidden.
+ */
+add_task(async function test_visibility_hidden() {
+  incrementTest();
+  let testPage =
+    "data:text/html;charset=utf-8," +
+    '<form target="t"><input type="url"  placeholder="url" value="http://" style="visibility: hidden;"><input id="s" type="button" value="check"></form>';
+  let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, testPage);
+  await BrowserTestUtils.synthesizeMouse(
+    "#s",
+    0,
+    0,
+    {},
+    gBrowser.selectedBrowser
+  );
+
+  checkPopupHide();
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/browser/modules/test/browser/formValidation/browser_validation_navigation.js b/browser/modules/test/browser/formValidation/browser_validation_navigation.js
new file mode 100644
index 0000000000..4dd793b983
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser_validation_navigation.js
@@ -0,0 +1,49 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Make sure that the form validation message disappears if we navigate
+ * immediately.
+ */
+add_task(async function test_navigate() {
+  var gInvalidFormPopup =
+    gBrowser.selectedBrowser.browsingContext.currentWindowGlobal
+      .getActor("FormValidation")
+      ._getAndMaybeCreatePanel(document);
+  ok(
+    gInvalidFormPopup,
+    "The browser should have a popup to show when a form is invalid"
+  );
+
+  await BrowserTestUtils.withNewTab(
+    "data:text/html,<body contenteditable='true'><button>Click me",
+    async function checkTab(browser) {
+      let promiseExampleLoaded = BrowserTestUtils.waitForNewTab(
+        browser.getTabBrowser(),
+        "https://example.com/",
+        true
+      );
+      await SpecialPowers.spawn(browser, [], () => {
+        let doc = content.document;
+        let input = doc.createElement("select");
+        input.style.opacity = 0;
+        doc.body.append(input);
+        input.setCustomValidity("This message should not show up.");
+        content.eval(
+          `document.querySelector("button").setAttribute("onmousedown", "document.querySelector('select').reportValidity();window.open('https://example.com/');")`
+        );
+      });
+      await BrowserTestUtils.synthesizeMouseAtCenter("button", {}, browser);
+      let otherTab = await promiseExampleLoaded;
+      await BrowserTestUtils.waitForPopupEvent(gInvalidFormPopup, "hidden");
+      is(
+        gInvalidFormPopup.state,
+        "closed",
+        "Invalid form popup should go away."
+      );
+      BrowserTestUtils.removeTab(otherTab);
+    }
+  );
+});
diff --git a/browser/modules/test/browser/formValidation/browser_validation_other_popups.js b/browser/modules/test/browser/formValidation/browser_validation_other_popups.js
new file mode 100644
index 0000000000..320dff0b59
--- /dev/null
+++ b/browser/modules/test/browser/formValidation/browser_validation_other_popups.js
@@ -0,0 +1,123 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+var gInvalidFormPopup =
+  gBrowser.selectedBrowser.browsingContext.currentWindowGlobal
+    .getActor("FormValidation")
+    ._getAndMaybeCreatePanel(document);
+
+add_task(async function test_other_popup_closes() {
+  ok(
+    gInvalidFormPopup,
+    "The browser should have a popup to show when a form is invalid"
+  );
+  await BrowserTestUtils.withNewTab(
+    "https://example.com/nothere",
+    async function checkTab(browser) {
+      let popupShown = BrowserTestUtils.waitForPopupEvent(
+        gInvalidFormPopup,
+        "shown"
+      );
+      await SpecialPowers.spawn(browser, [], () => {
+        let doc = content.document;
+        let input = doc.createElement("input");
+        doc.body.append(input);
+        input.setCustomValidity("This message should be hidden.");
+        content.eval(`document.querySelector('input').reportValidity();`);
+      });
+      let popupHidden = BrowserTestUtils.waitForPopupEvent(
+        gInvalidFormPopup,
+        "hidden"
+      );
+      await popupShown;
+      let notificationPopup = document.getElementById("notification-popup");
+      let notificationShown = BrowserTestUtils.waitForPopupEvent(
+        notificationPopup,
+        "shown"
+      );
+      let notificationHidden = BrowserTestUtils.waitForPopupEvent(
+        notificationPopup,
+        "hidden"
+      );
+      await SpecialPowers.spawn(browser, [], () => {
+        content.navigator.geolocation.getCurrentPosition(function () {});
+      });
+      await notificationShown;
+      // Should already be hidden at this point.
+      is(
+        gInvalidFormPopup.state,
+        "closed",
+        "Form validation popup should have closed"
+      );
+      // Close just in case.
+      if (gInvalidFormPopup.state != "closed") {
+        gInvalidFormPopup.hidePopup();
+      }
+      await popupHidden;
+      notificationPopup.hidePopup();
+      await notificationHidden;
+    }
+  );
+});
+
+add_task(async function test_dont_open_while_other_popup_open() {
+  ok(
+    gInvalidFormPopup,
+    "The browser should have a popup to show when a form is invalid"
+  );
+  await BrowserTestUtils.withNewTab(
+    "https://example.org/nothere",
+    async function checkTab(browser) {
+      let notificationPopup = document.getElementById("notification-popup");
+      let notificationShown = BrowserTestUtils.waitForPopupEvent(
+        notificationPopup,
+        "shown"
+      );
+      await SpecialPowers.spawn(browser, [], () => {
+        content.navigator.geolocation.getCurrentPosition(function () {});
+      });
+      await notificationShown;
+      let popupShown = BrowserTestUtils.waitForPopupEvent(
+        gInvalidFormPopup,
+        "shown"
+      );
+      is(
+        gInvalidFormPopup.state,
+        "closed",
+        "Form validation popup should be closed."
+      );
+      await SpecialPowers.spawn(browser, [], () => {
+        let doc = content.document;
+        let input = doc.createElement("input");
+        doc.body.append(input);
+        input.setCustomValidity("This message should be hidden.");
+        content.eval(`document.querySelector('input').reportValidity();`);
+      });
+      is(
+        gInvalidFormPopup.state,
+        "closed",
+        "Form validation popup should still be closed."
+      );
+      let notificationHidden = BrowserTestUtils.waitForPopupEvent(
+        notificationPopup,
+        "hidden"
+      );
+      notificationPopup
+        .querySelector(".popup-notification-secondary-button")
+        .click();
+      await notificationHidden;
+      await SpecialPowers.spawn(browser, [], () => {
+        content.eval(`document.querySelector('input').reportValidity();`);
+      });
+      await popupShown;
+      let popupHidden = BrowserTestUtils.waitForPopupEvent(
+        gInvalidFormPopup,
+        "hidden"
+      );
+      gInvalidFormPopup.hidePopup();
+      await popupHidden;
+    }
+  );
+});
diff --git a/browser/modules/test/browser/head.js b/browser/modules/test/browser/head.js
new file mode 100644
index 0000000000..f852cdd641
--- /dev/null
+++ b/browser/modules/test/browser/head.js
@@ -0,0 +1,331 @@
+ChromeUtils.defineESModuleGetters(this, {
+  PlacesTestUtils: "resource://testing-common/PlacesTestUtils.sys.mjs",
+  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+});
+
+const SINGLE_TRY_TIMEOUT = 100;
+const NUMBER_OF_TRIES = 30;
+
+function waitForConditionPromise(
+  condition,
+  timeoutMsg,
+  tryCount = NUMBER_OF_TRIES
+) {
+  return new Promise((resolve, reject) => {
+    let tries = 0;
+    function checkCondition() {
+      if (tries >= tryCount) {
+        reject(timeoutMsg);
+      }
+      var conditionPassed;
+      try {
+        conditionPassed = condition();
+      } catch (e) {
+        return reject(e);
+      }
+      if (conditionPassed) {
+        return resolve();
+      }
+      tries++;
+      setTimeout(checkCondition, SINGLE_TRY_TIMEOUT);
+      return undefined;
+    }
+    setTimeout(checkCondition, SINGLE_TRY_TIMEOUT);
+  });
+}
+
+function waitForCondition(condition, nextTest, errorMsg) {
+  waitForConditionPromise(condition, errorMsg).then(nextTest, reason => {
+    ok(false, reason + (reason.stack ? "\n" + reason.stack : ""));
+  });
+}
+
+/**
+ * An utility function to write some text in the search input box
+ * in a content page.
+ * @param {Object} browser
+ *        The browser that contains the content.
+ * @param {String} text
+ *        The string to write in the search field.
+ * @param {String} fieldName
+ *        The name of the field to write to.
+ */
+let typeInSearchField = async function (browser, text, fieldName) {
+  await SpecialPowers.spawn(
+    browser,
+    [[fieldName, text]],
+    async function ([contentFieldName, contentText]) {
+      // Put the focus on the search box.
+      let searchInput = content.document.getElementById(contentFieldName);
+      searchInput.focus();
+      searchInput.value = contentText;
+    }
+  );
+};
+
+/**
+ * Given a <xul:browser> at some non-internal web page,
+ * return something that resembles an nsIContentPermissionRequest,
+ * using the browsers currently loaded document to get a principal.
+ *
+ * @param browser (<xul:browser>)
+ *        The browser that we'll create a nsIContentPermissionRequest
+ *        for.
+ * @returns A nsIContentPermissionRequest-ish object.
+ */
+function makeMockPermissionRequest(browser) {
+  let type = {
+    options: Cc["@mozilla.org/array;1"].createInstance(Ci.nsIArray),
+    QueryInterface: ChromeUtils.generateQI(["nsIContentPermissionType"]),
+  };
+  let types = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+  types.appendElement(type);
+  let principal = browser.contentPrincipal;
+  let result = {
+    types,
+    isHandlingUserInput: false,
+    principal,
+    topLevelPrincipal: principal,
+    requester: null,
+    _cancelled: false,
+    cancel() {
+      this._cancelled = true;
+    },
+    _allowed: false,
+    allow() {
+      this._allowed = true;
+    },
+    getDelegatePrincipal(aType) {
+      return principal;
+    },
+    QueryInterface: ChromeUtils.generateQI(["nsIContentPermissionRequest"]),
+  };
+
+  // In the e10s-case, nsIContentPermissionRequest will have
+  // element defined. window is defined otherwise.
+  if (browser.isRemoteBrowser) {
+    result.element = browser;
+  } else {
+    result.window = browser.contentWindow;
+  }
+
+  return result;
+}
+
+/**
+ * For an opened PopupNotification, clicks on the main action,
+ * and waits for the panel to fully close.
+ *
+ * @return {Promise}
+ *         Resolves once the panel has fired the "popuphidden"
+ *         event.
+ */
+function clickMainAction() {
+  let removePromise = BrowserTestUtils.waitForEvent(
+    PopupNotifications.panel,
+    "popuphidden"
+  );
+  let popupNotification = getPopupNotificationNode();
+  popupNotification.button.click();
+  return removePromise;
+}
+
+/**
+ * For an opened PopupNotification, clicks on the secondary action,
+ * and waits for the panel to fully close.
+ *
+ * @param actionIndex (Number)
+ *        The index of the secondary action to be clicked. The default
+ *        secondary action (the button shown directly in the panel) is
+ *        treated as having index 0.
+ *
+ * @return {Promise}
+ *         Resolves once the panel has fired the "popuphidden"
+ *         event.
+ */
+function clickSecondaryAction(actionIndex) {
+  let removePromise = BrowserTestUtils.waitForEvent(
+    PopupNotifications.panel,
+    "popuphidden"
+  );
+  let popupNotification = getPopupNotificationNode();
+  if (!actionIndex) {
+    popupNotification.secondaryButton.click();
+    return removePromise;
+  }
+
+  return (async function () {
+    // Click the dropmarker arrow and wait for the menu to show up.
+    let dropdownPromise = BrowserTestUtils.waitForEvent(
+      popupNotification.menupopup,
+      "popupshown"
+    );
+    await EventUtils.synthesizeMouseAtCenter(popupNotification.menubutton, {});
+    await dropdownPromise;
+
+    // The menuitems in the dropdown are accessible as direct children of the panel,
+    // because they are injected into a <children> node in the XBL binding.
+    // The target action is the menuitem at index actionIndex - 1, because the first
+    // secondary action (index 0) is the button shown directly in the panel.
+    let actionMenuItem =
+      popupNotification.querySelectorAll("menuitem")[actionIndex - 1];
+    await EventUtils.synthesizeMouseAtCenter(actionMenuItem, {});
+    await removePromise;
+  })();
+}
+
+/**
+ * Makes sure that 1 (and only 1) <xul:popupnotification> is being displayed
+ * by PopupNotification, and then returns that <xul:popupnotification>.
+ *
+ * @return {<xul:popupnotification>}
+ */
+function getPopupNotificationNode() {
+  // PopupNotification is a bit overloaded here, so to be
+  // clear, popupNotifications is a list of <xul:popupnotification>
+  // nodes.
+  let popupNotifications = PopupNotifications.panel.childNodes;
+  Assert.equal(
+    popupNotifications.length,
+    1,
+    "Should be showing a <xul:popupnotification>"
+  );
+  return popupNotifications[0];
+}
+
+/**
+ * Disable non-release page actions (that are tested elsewhere).
+ *
+ * @return void
+ */
+async function disableNonReleaseActions() {
+  if (!["release", "esr"].includes(AppConstants.MOZ_UPDATE_CHANNEL)) {
+    SpecialPowers.Services.prefs.setBoolPref(
+      "extensions.webcompat-reporter.enabled",
+      false
+    );
+  }
+}
+
+function assertActivatedPageActionPanelHidden() {
+  Assert.ok(
+    !document.getElementById(BrowserPageActions._activatedActionPanelID)
+  );
+}
+
+function promiseOpenPageActionPanel() {
+  let dwu = window.windowUtils;
+  return TestUtils.waitForCondition(() => {
+    // Wait for the main page action button to become visible.  It's hidden for
+    // some URIs, so depending on when this is called, it may not yet be quite
+    // visible.  It's up to the caller to make sure it will be visible.
+    info("Waiting for main page action button to have non-0 size");
+    let bounds = dwu.getBoundsWithoutFlushing(
+      BrowserPageActions.mainButtonNode
+    );
+    return bounds.width > 0 && bounds.height > 0;
+  })
+    .then(() => {
+      // Wait for the panel to become open, by clicking the button if necessary.
+      info("Waiting for main page action panel to be open");
+      if (BrowserPageActions.panelNode.state == "open") {
+        return Promise.resolve();
+      }
+      let shownPromise = promisePageActionPanelShown();
+      EventUtils.synthesizeMouseAtCenter(BrowserPageActions.mainButtonNode, {});
+      return shownPromise;
+    })
+    .then(() => {
+      // Wait for items in the panel to become visible.
+      return promisePageActionViewChildrenVisible(
+        BrowserPageActions.mainViewNode
+      );
+    });
+}
+
+function promisePageActionPanelShown() {
+  return promisePanelShown(BrowserPageActions.panelNode);
+}
+
+function promisePageActionPanelHidden() {
+  return promisePanelHidden(BrowserPageActions.panelNode);
+}
+
+function promisePanelShown(panelIDOrNode) {
+  return promisePanelEvent(panelIDOrNode, "popupshown");
+}
+
+function promisePanelHidden(panelIDOrNode) {
+  return promisePanelEvent(panelIDOrNode, "popuphidden");
+}
+
+function promisePanelEvent(panelIDOrNode, eventType) {
+  return new Promise(resolve => {
+    let panel = panelIDOrNode;
+    if (typeof panel == "string") {
+      panel = document.getElementById(panelIDOrNode);
+      if (!panel) {
+        throw new Error(`Panel with ID "${panelIDOrNode}" does not exist.`);
+      }
+    }
+    if (
+      (eventType == "popupshown" && panel.state == "open") ||
+      (eventType == "popuphidden" && panel.state == "closed")
+    ) {
+      executeSoon(resolve);
+      return;
+    }
+    panel.addEventListener(
+      eventType,
+      () => {
+        executeSoon(resolve);
+      },
+      { once: true }
+    );
+  });
+}
+
+function promisePageActionViewShown() {
+  info("promisePageActionViewShown waiting for ViewShown");
+  return BrowserTestUtils.waitForEvent(
+    BrowserPageActions.panelNode,
+    "ViewShown"
+  ).then(async event => {
+    let panelViewNode = event.originalTarget;
+    await promisePageActionViewChildrenVisible(panelViewNode);
+    return panelViewNode;
+  });
+}
+
+async function promisePageActionViewChildrenVisible(panelViewNode) {
+  info(
+    "promisePageActionViewChildrenVisible waiting for a child node to be visible"
+  );
+  await new Promise(requestAnimationFrame);
+  let dwu = window.windowUtils;
+  return TestUtils.waitForCondition(() => {
+    let bodyNode = panelViewNode.firstElementChild;
+    for (let childNode of bodyNode.children) {
+      let bounds = dwu.getBoundsWithoutFlushing(childNode);
+      if (bounds.width > 0 && bounds.height > 0) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+async function initPageActionsTest() {
+  await disableNonReleaseActions();
+
+  // Ensure screenshots is really disabled (bug 1498738)
+  const addon = await AddonManager.getAddonByID("screenshots@mozilla.org");
+  await addon.disable({ allowSystemAddons: true });
+
+  // Make the main button visible. It's not unless the window is narrow. This
+  // test isn't concerned with that behavior. We have other tests for that.
+  BrowserPageActions.mainButtonNode.style.visibility = "visible";
+  registerCleanupFunction(() => {
+    BrowserPageActions.mainButtonNode.style.removeProperty("visibility");
+  });
+}
diff --git a/browser/modules/test/unit/test_E10SUtils_nested_URIs.js b/browser/modules/test/unit/test_E10SUtils_nested_URIs.js
new file mode 100644
index 0000000000..5ebcac114f
--- /dev/null
+++ b/browser/modules/test/unit/test_E10SUtils_nested_URIs.js
@@ -0,0 +1,90 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+
+const { E10SUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/E10SUtils.sys.mjs"
+);
+
+var TEST_PREFERRED_REMOTE_TYPES = [
+  E10SUtils.WEB_REMOTE_TYPE,
+  E10SUtils.NOT_REMOTE,
+  "fakeRemoteType",
+];
+
+// These test cases give a nestedURL and a plainURL that should always load in
+// the same remote type. By making these tests comparisons, they should work
+// with any pref combination.
+var TEST_CASES = [
+  {
+    nestedURL: "jar:file:///some.file!/",
+    plainURL: "file:///some.file",
+  },
+  {
+    nestedURL: "jar:jar:file:///some.file!/!/",
+    plainURL: "file:///some.file",
+  },
+  {
+    nestedURL: "jar:http://some.site/file!/",
+    plainURL: "http://some.site/file",
+  },
+  {
+    nestedURL: "view-source:http://some.site",
+    plainURL: "http://some.site",
+  },
+  {
+    nestedURL: "view-source:file:///some.file",
+    plainURL: "file:///some.file",
+  },
+  {
+    nestedURL: "view-source:about:home",
+    plainURL: "about:home",
+  },
+  {
+    nestedURL: "view-source:about:robots",
+    plainURL: "about:robots",
+  },
+  {
+    nestedURL: "view-source:pcast:http://some.site",
+    plainURL: "http://some.site",
+  },
+];
+
+function run_test() {
+  for (let testCase of TEST_CASES) {
+    for (let preferredRemoteType of TEST_PREFERRED_REMOTE_TYPES) {
+      let plainUri = Services.io.newURI(testCase.plainURL);
+      let plainRemoteType = E10SUtils.getRemoteTypeForURIObject(plainUri, {
+        multiProcess: true,
+        remoteSubFrames: false,
+        preferredRemoteType,
+      });
+
+      let nestedUri = Services.io.newURI(testCase.nestedURL);
+      let nestedRemoteType = E10SUtils.getRemoteTypeForURIObject(nestedUri, {
+        multiProcess: true,
+        remoteSubFrames: false,
+        preferredRemoteType,
+      });
+
+      let nestedStr = nestedUri.scheme + ":";
+      do {
+        nestedUri = nestedUri.QueryInterface(Ci.nsINestedURI).innerURI;
+        if (nestedUri.scheme == "about") {
+          nestedStr += nestedUri.spec;
+          break;
+        }
+
+        nestedStr += nestedUri.scheme + ":";
+      } while (nestedUri instanceof Ci.nsINestedURI);
+
+      let plainStr =
+        plainUri.scheme == "about" ? plainUri.spec : plainUri.scheme + ":";
+      equal(
+        nestedRemoteType,
+        plainRemoteType,
+        `Check that ${nestedStr} loads in same remote type as ${plainStr}` +
+          ` with preferred remote type: ${preferredRemoteType}`
+      );
+    }
+  }
+}
diff --git a/browser/modules/test/unit/test_HomePage.js b/browser/modules/test/unit/test_HomePage.js
new file mode 100644
index 0000000000..f2f4588329
--- /dev/null
+++ b/browser/modules/test/unit/test_HomePage.js
@@ -0,0 +1,85 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  HomePage: "resource:///modules/HomePage.sys.mjs",
+  RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",
+  sinon: "resource://testing-common/Sinon.sys.mjs",
+});
+
+const HOMEPAGE_IGNORELIST = "homepage-urls";
+
+/**
+ * Provides a basic set of remote settings for use in tests.
+ */
+async function setupRemoteSettings() {
+  const settings = await RemoteSettings("hijack-blocklists");
+  sinon.stub(settings, "get").returns([
+    {
+      id: HOMEPAGE_IGNORELIST,
+      matches: ["ignore=me"],
+      _status: "synced",
+    },
+  ]);
+}
+
+add_task(async function setup() {
+  await setupRemoteSettings();
+});
+
+add_task(function test_HomePage() {
+  Assert.ok(
+    !HomePage.overridden,
+    "Homepage should not be overriden by default."
+  );
+  let newvalue = "about:blank|about:newtab";
+  HomePage.safeSet(newvalue);
+  Assert.ok(HomePage.overridden, "Homepage should be overriden after set()");
+  Assert.equal(HomePage.get(), newvalue, "Homepage should be ${newvalue}");
+  Assert.notEqual(
+    HomePage.getDefault(),
+    newvalue,
+    "Homepage should be ${newvalue}"
+  );
+  HomePage.reset();
+  Assert.ok(
+    !HomePage.overridden,
+    "Homepage should not be overriden by after reset."
+  );
+  Assert.equal(
+    HomePage.get(),
+    HomePage.getDefault(),
+    "Homepage and default should be equal after reset."
+  );
+});
+
+add_task(function test_readLocalizedHomepage() {
+  let newvalue = "data:text/plain,browser.startup.homepage%3Dabout%3Alocalized";
+  let complexvalue = Cc["@mozilla.org/pref-localizedstring;1"].createInstance(
+    Ci.nsIPrefLocalizedString
+  );
+  complexvalue.data = newvalue;
+  Services.prefs
+    .getDefaultBranch(null)
+    .setComplexValue(
+      "browser.startup.homepage",
+      Ci.nsIPrefLocalizedString,
+      complexvalue
+    );
+  Assert.ok(!HomePage.overridden, "Complex value only works as default");
+  Assert.equal(HomePage.get(), "about:localized", "Get value from bundle");
+});
+
+add_task(function test_recoverEmptyHomepage() {
+  Assert.ok(
+    !HomePage.overridden,
+    "Homepage should not be overriden by default."
+  );
+  Services.prefs.setStringPref("browser.startup.homepage", "");
+  Assert.ok(HomePage.overridden, "Homepage is overriden with empty string.");
+  Assert.equal(HomePage.get(), HomePage.getDefault(), "Recover is default");
+  Assert.ok(!HomePage.overridden, "Recover should have set default");
+});
diff --git a/browser/modules/test/unit/test_HomePage_ignore.js b/browser/modules/test/unit/test_HomePage_ignore.js
new file mode 100644
index 0000000000..1369b661b6
--- /dev/null
+++ b/browser/modules/test/unit/test_HomePage_ignore.js
@@ -0,0 +1,128 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+ChromeUtils.defineESModuleGetters(this, {
+  HomePage: "resource:///modules/HomePage.sys.mjs",
+  RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",
+  TelemetryTestUtils: "resource://testing-common/TelemetryTestUtils.sys.mjs",
+  sinon: "resource://testing-common/Sinon.sys.mjs",
+});
+
+const HOMEPAGE_IGNORELIST = "homepage-urls";
+
+/**
+ * Provides a basic set of remote settings for use in tests.
+ */
+async function setupRemoteSettings() {
+  const settings = await RemoteSettings("hijack-blocklists");
+  sinon.stub(settings, "get").returns([
+    {
+      id: HOMEPAGE_IGNORELIST,
+      matches: ["ignore=me", "ignoreCASE=ME"],
+      _status: "synced",
+    },
+  ]);
+}
+
+add_task(async function setup() {
+  await setupRemoteSettings();
+});
+
+add_task(async function test_initWithIgnoredPageCausesReset() {
+  // Set the preference direct as the set() would block us.
+  Services.prefs.setStringPref(
+    "browser.startup.homepage",
+    "http://bad/?ignore=me"
+  );
+  Assert.ok(HomePage.overridden, "Should have overriden the homepage");
+
+  await HomePage.delayedStartup();
+
+  Assert.ok(
+    !HomePage.overridden,
+    "Should no longer be overriding the homepage."
+  );
+  Assert.equal(
+    HomePage.get(),
+    HomePage.getDefault(),
+    "Should have reset to the default preference"
+  );
+
+  TelemetryTestUtils.assertEvents(
+    [{ object: "ignore", value: "saved_reset" }],
+    {
+      category: "homepage",
+      method: "preference",
+    }
+  );
+});
+
+add_task(async function test_updateIgnoreListCausesReset() {
+  Services.prefs.setStringPref(
+    "browser.startup.homepage",
+    "http://bad/?new=ignore"
+  );
+  Assert.ok(HomePage.overridden, "Should have overriden the homepage");
+
+  // Simulate an ignore list update.
+  await RemoteSettings("hijack-blocklists").emit("sync", {
+    data: {
+      current: [
+        {
+          id: HOMEPAGE_IGNORELIST,
+          schema: 1553857697843,
+          last_modified: 1553859483588,
+          matches: ["ignore=me", "ignoreCASE=ME", "new=ignore"],
+        },
+      ],
+    },
+  });
+
+  Assert.ok(
+    !HomePage.overridden,
+    "Should no longer be overriding the homepage."
+  );
+  Assert.equal(
+    HomePage.get(),
+    HomePage.getDefault(),
+    "Should have reset to the default preference"
+  );
+  TelemetryTestUtils.assertEvents(
+    [{ object: "ignore", value: "saved_reset" }],
+    {
+      category: "homepage",
+      method: "preference",
+    }
+  );
+});
+
+async function testSetIgnoredUrl(url) {
+  Assert.ok(!HomePage.overriden, "Should not be overriding the homepage");
+
+  await HomePage.set(url);
+
+  Assert.equal(
+    HomePage.get(),
+    HomePage.getDefault(),
+    "Should still have the default homepage."
+  );
+  Assert.ok(!HomePage.overriden, "Should not be overriding the homepage.");
+  TelemetryTestUtils.assertEvents(
+    [{ object: "ignore", value: "set_blocked" }],
+    {
+      category: "homepage",
+      method: "preference",
+    }
+  );
+}
+
+add_task(async function test_setIgnoredUrl() {
+  await testSetIgnoredUrl("http://bad/?ignore=me");
+});
+
+add_task(async function test_setIgnoredUrl_case() {
+  await testSetIgnoredUrl("http://bad/?Ignorecase=me");
+});
diff --git a/browser/modules/test/unit/test_InstallationTelemetry.js b/browser/modules/test/unit/test_InstallationTelemetry.js
new file mode 100644
index 0000000000..4bb9acbd75
--- /dev/null
+++ b/browser/modules/test/unit/test_InstallationTelemetry.js
@@ -0,0 +1,234 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+const { BrowserUsageTelemetry } = ChromeUtils.importESModule(
+  "resource:///modules/BrowserUsageTelemetry.sys.mjs"
+);
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+ChromeUtils.defineESModuleGetters(this, {
+  FileUtils: "resource://gre/modules/FileUtils.sys.mjs",
+});
+
+const TIMESTAMP_PREF = "app.installation.timestamp";
+
+function encodeUtf16(str) {
+  const buf = new ArrayBuffer(str.length * 2);
+  const utf16 = new Uint16Array(buf);
+  for (let i = 0; i < str.length; i++) {
+    utf16[i] = str.charCodeAt(i);
+  }
+  return new Uint8Array(buf);
+}
+
+// Returns Promise
+function writeJsonUtf16(fileName, obj) {
+  const str = JSON.stringify(obj);
+  return IOUtils.write(fileName, encodeUtf16(str));
+}
+
+async function runReport(
+  dataFile,
+  installType,
+  { clearTS, setTS, assertRejects, expectExtra, expectTS, msixPrefixes }
+) {
+  // Setup timestamp
+  if (clearTS) {
+    Services.prefs.clearUserPref(TIMESTAMP_PREF);
+  }
+  if (typeof setTS == "string") {
+    Services.prefs.setStringPref(TIMESTAMP_PREF, setTS);
+  }
+
+  // Init events
+  Services.telemetry.clearEvents();
+
+  // Exercise reportInstallationTelemetry
+  if (typeof assertRejects != "undefined") {
+    await Assert.rejects(
+      BrowserUsageTelemetry.reportInstallationTelemetry(dataFile),
+      assertRejects
+    );
+  } else if (!msixPrefixes) {
+    await BrowserUsageTelemetry.reportInstallationTelemetry(dataFile);
+  } else {
+    await BrowserUsageTelemetry.reportInstallationTelemetry(
+      dataFile,
+      msixPrefixes
+    );
+  }
+
+  // Check events
+  TelemetryTestUtils.assertEvents(
+    expectExtra
+      ? [{ object: installType, value: null, extra: expectExtra }]
+      : [],
+    { category: "installation", method: "first_seen" }
+  );
+
+  // Check timestamp
+  if (typeof expectTS == "string") {
+    Assert.equal(expectTS, Services.prefs.getStringPref(TIMESTAMP_PREF));
+  }
+}
+
+let condition = {
+  skip_if: () =>
+    AppConstants.platform !== "win" ||
+    !Services.sysinfo.getProperty("hasWinPackageId"),
+};
+add_task(condition, async function testInstallationTelemetryMSIX() {
+  // Unfortunately, we have no way to inject different installation ping data
+  // into the system in a way that doesn't just completely override the code
+  // under test - so other than a basic test of the happy path, there's
+  // nothing we can do here.
+  let msixExtra = {
+    version: AppConstants.MOZ_APP_VERSION,
+    build_id: AppConstants.MOZ_BULIDID,
+    admin_user: "false",
+    from_msi: "false",
+    silent: "false",
+    default_path: "true",
+    install_existed: "false",
+    other_inst: "false",
+    other_msix_inst: "false",
+    profdir_existed: "false",
+  };
+
+  await runReport("fake", "msix", {
+    expectExtra: msixExtra,
+  });
+});
+condition = {
+  skip_if: () =>
+    AppConstants.platform === "win" &&
+    Services.sysinfo.getProperty("hasWinPackageId"),
+};
+add_task(condition, async function testInstallationTelemetry() {
+  let dataFilePath = await IOUtils.createUniqueFile(
+    Services.dirsvc.get("TmpD", Ci.nsIFile).path,
+    "installation-telemetry-test-data" + Math.random() + ".json"
+  );
+  let dataFile = new FileUtils.File(dataFilePath);
+
+  registerCleanupFunction(async () => {
+    try {
+      await IOUtils.remove(dataFilePath);
+    } catch (ex) {
+      // Ignore remove failure, file may not exist by now
+    }
+
+    Services.prefs.clearUserPref(TIMESTAMP_PREF);
+  });
+
+  // Test with normal stub data
+  let stubData = {
+    version: "99.0abc",
+    build_id: "123",
+    installer_type: "stub",
+    admin_user: true,
+    install_existed: false,
+    profdir_existed: false,
+    install_timestamp: "0",
+  };
+  let stubExtra = {
+    version: "99.0abc",
+    build_id: "123",
+    admin_user: "true",
+    install_existed: "false",
+    other_inst: "false",
+    other_msix_inst: "false",
+    profdir_existed: "false",
+  };
+
+  await writeJsonUtf16(dataFilePath, stubData);
+  await runReport(dataFile, "stub", {
+    clearTS: true,
+    expectExtra: stubExtra,
+    expectTS: "0",
+  });
+
+  // Check that it doesn't generate another event when the timestamp is unchanged
+  await runReport(dataFile, "stub", { expectTS: "0" });
+
+  // New timestamp
+  stubData.install_timestamp = "1";
+  await writeJsonUtf16(dataFilePath, stubData);
+  await runReport(dataFile, "stub", {
+    expectExtra: stubExtra,
+    expectTS: "1",
+  });
+
+  // Test with normal full data
+  let fullData = {
+    version: "99.0abc",
+    build_id: "123",
+    installer_type: "full",
+    admin_user: false,
+    install_existed: true,
+    profdir_existed: true,
+    silent: false,
+    from_msi: false,
+    default_path: true,
+
+    install_timestamp: "1",
+  };
+  let fullExtra = {
+    version: "99.0abc",
+    build_id: "123",
+    admin_user: "false",
+    install_existed: "true",
+    other_inst: "false",
+    other_msix_inst: "false",
+    profdir_existed: "true",
+    silent: "false",
+    from_msi: "false",
+    default_path: "true",
+  };
+
+  await writeJsonUtf16(dataFilePath, fullData);
+  await runReport(dataFile, "full", {
+    clearTS: true,
+    expectExtra: fullExtra,
+    expectTS: "1",
+  });
+
+  // Check that it doesn't generate another event when the timestamp is unchanged
+  await runReport(dataFile, "full", { expectTS: "1" });
+
+  // New timestamp and a check to make sure we can find installed MSIX packages
+  // by overriding the prefixes a bit further down.
+  fullData.install_timestamp = "2";
+  // This check only works on Windows
+  if (AppConstants.platform == "win") {
+    fullExtra.other_msix_inst = "true";
+  }
+  await writeJsonUtf16(dataFilePath, fullData);
+  await runReport(dataFile, "full", {
+    expectExtra: fullExtra,
+    expectTS: "2",
+    msixPrefixes: ["Microsoft"],
+  });
+
+  // Missing field
+  delete fullData.install_existed;
+  fullData.install_timestamp = "3";
+  await writeJsonUtf16(dataFilePath, fullData);
+  await runReport(dataFile, "full", { assertRejects: /install_existed/ });
+
+  // Malformed JSON
+  await IOUtils.write(dataFilePath, encodeUtf16("hello"));
+  await runReport(dataFile, "stub", {
+    assertRejects: /unexpected character/,
+  });
+
+  // Missing file, should return with no exception
+  await IOUtils.remove(dataFilePath);
+  await runReport(dataFile, "stub", { setTS: "3", expectTS: "3" });
+});
diff --git a/browser/modules/test/unit/test_LaterRun.js b/browser/modules/test/unit/test_LaterRun.js
new file mode 100644
index 0000000000..6de572b868
--- /dev/null
+++ b/browser/modules/test/unit/test_LaterRun.js
@@ -0,0 +1,244 @@
+"use strict";
+
+const kEnabledPref = "browser.laterrun.enabled";
+const kPagePrefRoot = "browser.laterrun.pages.";
+const kSessionCountPref = "browser.laterrun.bookkeeping.sessionCount";
+const kProfileCreationTime = "browser.laterrun.bookkeeping.profileCreationTime";
+
+const { LaterRun } = ChromeUtils.importESModule(
+  "resource:///modules/LaterRun.sys.mjs"
+);
+
+Services.prefs.setBoolPref(kEnabledPref, true);
+const { updateAppInfo } = ChromeUtils.importESModule(
+  "resource://testing-common/AppInfo.sys.mjs"
+);
+updateAppInfo();
+
+add_task(async function test_page_applies() {
+  Services.prefs.setCharPref(
+    kPagePrefRoot + "test_LaterRun_unittest.url",
+    "https://www.mozilla.org/%VENDOR%/%NAME%/%ID%/%VERSION%/"
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumHoursSinceInstall",
+    10
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumSessionCount",
+    3
+  );
+
+  let pages = LaterRun.readPages();
+  // We have to filter the pages because it's possible Firefox ships with other URLs
+  // that get included in this test.
+  pages = pages.filter(
+    page => page.pref == kPagePrefRoot + "test_LaterRun_unittest."
+  );
+  Assert.equal(pages.length, 1, "Got 1 page");
+  let page = pages[0];
+  Assert.equal(
+    page.pref,
+    kPagePrefRoot + "test_LaterRun_unittest.",
+    "Should know its own pref"
+  );
+  Assert.equal(
+    page.minimumHoursSinceInstall,
+    10,
+    "Needs to have 10 hours since install"
+  );
+  Assert.equal(page.minimumSessionCount, 3, "Needs to have 3 sessions");
+  Assert.equal(page.requireBoth, false, "Either requirement is enough");
+  let expectedURL =
+    "https://www.mozilla.org/" +
+    Services.appinfo.vendor +
+    "/" +
+    Services.appinfo.name +
+    "/" +
+    Services.appinfo.ID +
+    "/" +
+    Services.appinfo.version +
+    "/";
+  Assert.equal(page.url, expectedURL, "URL is stored correctly");
+
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 1, sessionCount: 3 }),
+    "Applies when session count has been met."
+  );
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 1, sessionCount: 4 }),
+    "Applies when session count has been exceeded."
+  );
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 10, sessionCount: 2 }),
+    "Applies when total session time has been met."
+  );
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 20, sessionCount: 2 }),
+    "Applies when total session time has been exceeded."
+  );
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 10, sessionCount: 3 }),
+    "Applies when both time and session count have been met."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 1 }),
+    "Does not apply when neither time and session count have been met."
+  );
+
+  page.requireBoth = true;
+
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 3 }),
+    "Does not apply when only session count has been met."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 4 }),
+    "Does not apply when only session count has been exceeded."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 10, sessionCount: 2 }),
+    "Does not apply when only total session time has been met."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 20, sessionCount: 2 }),
+    "Does not apply when only total session time has been exceeded."
+  );
+  Assert.ok(
+    page.applies({ hoursSinceInstall: 10, sessionCount: 3 }),
+    "Applies when both time and session count have been met."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 1 }),
+    "Does not apply when neither time and session count have been met."
+  );
+
+  // Check that pages that have run never apply:
+  Services.prefs.setBoolPref(
+    kPagePrefRoot + "test_LaterRun_unittest.hasRun",
+    true
+  );
+  page.requireBoth = false;
+
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 3 }),
+    "Does not apply when page has already run (sessionCount equal)."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 4 }),
+    "Does not apply when page has already run (sessionCount exceeding)."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 10, sessionCount: 2 }),
+    "Does not apply when page has already run (hoursSinceInstall equal)."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 20, sessionCount: 2 }),
+    "Does not apply when page has already run (hoursSinceInstall exceeding)."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 10, sessionCount: 3 }),
+    "Does not apply when page has already run (both criteria equal)."
+  );
+  Assert.ok(
+    !page.applies({ hoursSinceInstall: 1, sessionCount: 1 }),
+    "Does not apply when page has already run (both criteria insufficient anyway)."
+  );
+
+  clearAllPagePrefs();
+});
+
+add_task(async function test_get_URL() {
+  Services.prefs.setIntPref(
+    kProfileCreationTime,
+    Math.floor((Date.now() - 11 * 60 * 60 * 1000) / 1000)
+  );
+  Services.prefs.setCharPref(
+    kPagePrefRoot + "test_LaterRun_unittest.url",
+    "https://www.mozilla.org/"
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumHoursSinceInstall",
+    10
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumSessionCount",
+    3
+  );
+  let pages = LaterRun.readPages();
+  // We have to filter the pages because it's possible Firefox ships with other URLs
+  // that get included in this test.
+  pages = pages.filter(
+    page => page.pref == kPagePrefRoot + "test_LaterRun_unittest."
+  );
+  Assert.equal(pages.length, 1, "Should only be 1 matching page");
+  let page = pages[0];
+  let url;
+  do {
+    url = LaterRun.getURL();
+    // We have to loop because it's possible Firefox ships with other URLs that get triggered by
+    // this test.
+  } while (url && url != "https://www.mozilla.org/");
+  Assert.equal(
+    url,
+    "https://www.mozilla.org/",
+    "URL should be as expected when prefs are set."
+  );
+  Assert.ok(
+    Services.prefs.prefHasUserValue(
+      kPagePrefRoot + "test_LaterRun_unittest.hasRun"
+    ),
+    "Should have set pref"
+  );
+  Assert.ok(
+    Services.prefs.getBoolPref(kPagePrefRoot + "test_LaterRun_unittest.hasRun"),
+    "Should have set pref to true"
+  );
+  Assert.ok(page.hasRun, "Other page objects should know it has run, too.");
+
+  clearAllPagePrefs();
+});
+
+add_task(async function test_insecure_urls() {
+  Services.prefs.setCharPref(
+    kPagePrefRoot + "test_LaterRun_unittest.url",
+    "http://www.mozilla.org/"
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumHoursSinceInstall",
+    10
+  );
+  Services.prefs.setIntPref(
+    kPagePrefRoot + "test_LaterRun_unittest.minimumSessionCount",
+    3
+  );
+  let pages = LaterRun.readPages();
+  // We have to filter the pages because it's possible Firefox ships with other URLs
+  // that get triggered in this test.
+  pages = pages.filter(
+    page => page.pref == kPagePrefRoot + "test_LaterRun_unittest."
+  );
+  Assert.equal(pages.length, 0, "URL with non-https scheme should get ignored");
+  clearAllPagePrefs();
+});
+
+add_task(async function test_dynamic_pref_getter_setter() {
+  delete LaterRun._sessionCount;
+  Services.prefs.setIntPref(kSessionCountPref, 0);
+  Assert.equal(LaterRun.sessionCount, 0, "Should start at 0");
+
+  LaterRun.sessionCount++;
+  Assert.equal(LaterRun.sessionCount, 1, "Should increment.");
+  Assert.equal(
+    Services.prefs.getIntPref(kSessionCountPref),
+    1,
+    "Should update pref"
+  );
+});
+
+function clearAllPagePrefs() {
+  let allChangedPrefs = Services.prefs.getChildList(kPagePrefRoot);
+  for (let pref of allChangedPrefs) {
+    Services.prefs.clearUserPref(pref);
+  }
+}
diff --git a/browser/modules/test/unit/test_ProfileCounter.js b/browser/modules/test/unit/test_ProfileCounter.js
new file mode 100644
index 0000000000..2a22d849ff
--- /dev/null
+++ b/browser/modules/test/unit/test_ProfileCounter.js
@@ -0,0 +1,239 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { BrowserUsageTelemetry } = ChromeUtils.importESModule(
+  "resource:///modules/BrowserUsageTelemetry.sys.mjs"
+);
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+
+const PROFILE_COUNT_SCALAR = "browser.engagement.profile_count";
+// Largest possible uint32_t value represents an error.
+const SCALAR_ERROR_VALUE = 0;
+
+const FILE_OPEN_OPERATION = "open";
+const ERROR_FILE_NOT_FOUND = "NotFoundError";
+const ERROR_ACCESS_DENIED = "NotAllowedError";
+
+// We will redirect I/O to/from the profile counter file to read/write this
+// variable instead. That makes it easier for us to:
+//   - avoid interference from any pre-existing file
+//   - read and change the values in the file.
+//   - clean up changes made to the file
+// We will translate a null value stored here to a File Not Found error.
+var gFakeProfileCounterFile = null;
+// We will use this to check that the profile counter code doesn't try to write
+// to multiple files (since this test will malfunction in that case due to
+// gFakeProfileCounterFile only being setup to accommodate a single file).
+var gProfileCounterFilePath = null;
+
+// Storing a value here lets us test the behavior when we encounter an error
+// reading or writing to the file. A null value means that no error will
+// be simulated (other than possibly a NotFoundError).
+var gNextReadExceptionReason = null;
+var gNextWriteExceptionReason = null;
+
+// Nothing will actually be stored in this directory, so it's not important that
+// it be valid, but the leafname should be unique to this test in order to be
+// sure of preventing name conflicts with the pref:
+// `browser.engagement.profileCounted.${hash}`
+function getDummyUpdateDirectory() {
+  const testName = "test_ProfileCounter";
+  let dir = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+  dir.initWithPath(`C:\\foo\\bar\\${testName}`);
+  return dir;
+}
+
+// We aren't going to bother generating anything looking like a real client ID
+// for this. The only real requirements for client ids is that they not repeat
+// and that they be strings. So we'll just return an integer as a string and
+// increment it when we want a new client id.
+var gDummyTelemetryClientId = 0;
+function getDummyTelemetryClientId() {
+  return gDummyTelemetryClientId.toString();
+}
+function setNewDummyTelemetryClientId() {
+  ++gDummyTelemetryClientId;
+}
+
+// Returns null if the (fake) profile count file hasn't been created yet.
+function getProfileCount() {
+  // Strict equality to ensure distinguish properly between a non-existent
+  // file and an empty one.
+  if (gFakeProfileCounterFile === null) {
+    return null;
+  }
+  let saveData = JSON.parse(gFakeProfileCounterFile);
+  return saveData.profileTelemetryIds.length;
+}
+
+// Resets the state to the original state, before the profile count file has
+// even been written.
+// If resetFile is specified as false, this will reset everything except for the
+// file itself. This allows us to sort of pretend that another installation
+// wrote the file.
+function reset(resetFile = true) {
+  if (resetFile) {
+    gFakeProfileCounterFile = null;
+  }
+  gNextReadExceptionReason = null;
+  gNextWriteExceptionReason = null;
+  setNewDummyTelemetryClientId();
+}
+
+function setup() {
+  reset();
+  // FOG needs a profile directory to put its data in.
+  do_get_profile();
+  // Initialize FOG so we can test the FOG version of profile count
+  Services.fog.initializeFOG();
+  Services.fog.testResetFOG();
+
+  BrowserUsageTelemetry.Policy.readProfileCountFile = async path => {
+    if (!gProfileCounterFilePath) {
+      gProfileCounterFilePath = path;
+    } else {
+      // We've only got one mock-file variable. Make sure we are always
+      // accessing the same file or this will cause problems.
+      Assert.equal(
+        gProfileCounterFilePath,
+        path,
+        "Only one file should be accessed"
+      );
+    }
+    // Strict equality to ensure distinguish properly between null and 0.
+    if (gNextReadExceptionReason !== null) {
+      let ex = new DOMException(FILE_OPEN_OPERATION, gNextReadExceptionReason);
+      gNextReadExceptionReason = null;
+      throw ex;
+    }
+    // Strict equality to ensure distinguish properly between a non-existent
+    // file and an empty one.
+    if (gFakeProfileCounterFile === null) {
+      throw new DOMException(FILE_OPEN_OPERATION, ERROR_FILE_NOT_FOUND);
+    }
+    return gFakeProfileCounterFile;
+  };
+  BrowserUsageTelemetry.Policy.writeProfileCountFile = async (path, data) => {
+    if (!gProfileCounterFilePath) {
+      gProfileCounterFilePath = path;
+    } else {
+      // We've only got one mock-file variable. Make sure we are always
+      // accessing the same file or this will cause problems.
+      Assert.equal(
+        gProfileCounterFilePath,
+        path,
+        "Only one file should be accessed"
+      );
+    }
+    // Strict equality to ensure distinguish properly between null and 0.
+    if (gNextWriteExceptionReason !== null) {
+      let ex = new DOMException(FILE_OPEN_OPERATION, gNextWriteExceptionReason);
+      gNextWriteExceptionReason = null;
+      throw ex;
+    }
+    gFakeProfileCounterFile = data;
+  };
+  BrowserUsageTelemetry.Policy.getUpdateDirectory = getDummyUpdateDirectory;
+  BrowserUsageTelemetry.Policy.getTelemetryClientId = getDummyTelemetryClientId;
+}
+
+// Checks that the number of profiles reported is the number expected. Because
+// of bucketing, the raw count may be different than the reported count.
+function checkSuccess(profilesReported, rawCount = profilesReported) {
+  Assert.equal(rawCount, getProfileCount());
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+  TelemetryTestUtils.assertScalar(
+    scalars,
+    PROFILE_COUNT_SCALAR,
+    profilesReported,
+    "The value reported to telemetry should be the expected profile count"
+  );
+  Assert.equal(
+    profilesReported,
+    Glean.browserEngagement.profileCount.testGetValue()
+  );
+}
+
+function checkError() {
+  const scalars = TelemetryTestUtils.getProcessScalars("parent");
+  TelemetryTestUtils.assertScalar(
+    scalars,
+    PROFILE_COUNT_SCALAR,
+    SCALAR_ERROR_VALUE,
+    "The value reported to telemetry should be the error value"
+  );
+}
+
+add_task(async function testProfileCounter() {
+  setup();
+
+  info("Testing basic functionality, single install");
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkSuccess(1);
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkSuccess(1);
+
+  // Fake another installation by resetting everything except for the profile
+  // count file.
+  reset(false);
+
+  info("Testing basic functionality, faking a second install");
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkSuccess(2);
+
+  // Check if we properly handle the case where we cannot read from the file
+  // and we have already set its contents. This should report an error.
+  info("Testing read error after successful write");
+  gNextReadExceptionReason = ERROR_ACCESS_DENIED;
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkError();
+
+  reset();
+
+  // A read error should cause an error to be reported, but should also write
+  // to the file in an attempt to fix it. So the next (successful) read should
+  // result in the correct telemetry.
+  info("Testing read error self-correction");
+  gNextReadExceptionReason = ERROR_ACCESS_DENIED;
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkError();
+
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkSuccess(1);
+
+  reset();
+
+  // If the file is malformed. We should report an error and fix it, then report
+  // the correct profile count next time.
+  info("Testing with malformed profile count file");
+  gFakeProfileCounterFile = "<malformed file data>";
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkError();
+
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkSuccess(1);
+
+  reset();
+
+  // If we haven't yet written to the file, a write error should cause an error
+  // to be reported.
+  info("Testing write error before the first write");
+  gNextWriteExceptionReason = ERROR_ACCESS_DENIED;
+  await BrowserUsageTelemetry.reportProfileCount();
+  checkError();
+
+  reset();
+
+  info("Testing bucketing");
+  // Fake 15 installations to drive the raw profile count up to 15.
+  for (let i = 0; i < 15; i++) {
+    reset(false);
+    await BrowserUsageTelemetry.reportProfileCount();
+  }
+  // With bucketing, values from 10-99 should all be reported as 10.
+  checkSuccess(10, 15);
+});
diff --git a/browser/modules/test/unit/test_Sanitizer_interrupted.js b/browser/modules/test/unit/test_Sanitizer_interrupted.js
new file mode 100644
index 0000000000..c8e7130ac0
--- /dev/null
+++ b/browser/modules/test/unit/test_Sanitizer_interrupted.js
@@ -0,0 +1,139 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+do_get_profile();
+
+// Test that interrupted sanitizations are properly tracked.
+
+add_task(async function () {
+  const { Sanitizer } = ChromeUtils.importESModule(
+    "resource:///modules/Sanitizer.sys.mjs"
+  );
+
+  Services.prefs.setBoolPref(Sanitizer.PREF_NEWTAB_SEGREGATION, false);
+
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN);
+    Services.prefs.clearUserPref(Sanitizer.PREF_SHUTDOWN_BRANCH + "formdata");
+    Services.prefs.clearUserPref(Sanitizer.PREF_NEWTAB_SEGREGATION);
+  });
+  Services.prefs.setBoolPref(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN, true);
+  Services.prefs.setBoolPref(Sanitizer.PREF_SHUTDOWN_BRANCH + "formdata", true);
+
+  await Sanitizer.onStartup();
+  Assert.ok(Sanitizer.shouldSanitizeOnShutdown, "Should sanitize on shutdown");
+
+  let pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    1,
+    "Should have 1 pending sanitization"
+  );
+  Assert.equal(
+    pendingSanitizations[0].id,
+    "shutdown",
+    "Should be the shutdown sanitization"
+  );
+  Assert.ok(
+    pendingSanitizations[0].itemsToClear.includes("formdata"),
+    "Pref has been setup"
+  );
+  Assert.ok(
+    !pendingSanitizations[0].options.isShutdown,
+    "Shutdown option is not present"
+  );
+
+  // Check the preference listeners.
+  Services.prefs.setBoolPref(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN, false);
+  pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    0,
+    "Should not have pending sanitizations"
+  );
+  Assert.ok(
+    !Sanitizer.shouldSanitizeOnShutdown,
+    "Should not sanitize on shutdown"
+  );
+  Services.prefs.setBoolPref(Sanitizer.PREF_SANITIZE_ON_SHUTDOWN, true);
+  pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    1,
+    "Should have 1 pending sanitization"
+  );
+  Assert.equal(
+    pendingSanitizations[0].id,
+    "shutdown",
+    "Should be the shutdown sanitization"
+  );
+
+  Assert.ok(
+    pendingSanitizations[0].itemsToClear.includes("formdata"),
+    "Pending sanitizations should include formdata"
+  );
+  Services.prefs.setBoolPref(
+    Sanitizer.PREF_SHUTDOWN_BRANCH + "formdata",
+    false
+  );
+  pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    1,
+    "Should have 1 pending sanitization"
+  );
+  Assert.ok(
+    !pendingSanitizations[0].itemsToClear.includes("formdata"),
+    "Pending sanitizations should have been updated"
+  );
+
+  // Check a sanitization properly rebuilds the pref.
+  await Sanitizer.sanitize(["formdata"]);
+  pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    1,
+    "Should have 1 pending sanitization"
+  );
+  Assert.equal(
+    pendingSanitizations[0].id,
+    "shutdown",
+    "Should be the shutdown sanitization"
+  );
+
+  // Startup should run the pending one and setup a new shutdown sanitization.
+  Services.prefs.setBoolPref(
+    Sanitizer.PREF_SHUTDOWN_BRANCH + "formdata",
+    false
+  );
+  await Sanitizer.onStartup();
+  pendingSanitizations = JSON.parse(
+    Services.prefs.getStringPref(Sanitizer.PREF_PENDING_SANITIZATIONS, "[]")
+  );
+  Assert.equal(
+    pendingSanitizations.length,
+    1,
+    "Should have 1 pending sanitization"
+  );
+  Assert.equal(
+    pendingSanitizations[0].id,
+    "shutdown",
+    "Should be the shutdown sanitization"
+  );
+  Assert.ok(
+    !pendingSanitizations[0].itemsToClear.includes("formdata"),
+    "Pref has been setup"
+  );
+});
diff --git a/browser/modules/test/unit/test_SiteDataManager.js b/browser/modules/test/unit/test_SiteDataManager.js
new file mode 100644
index 0000000000..87bb511d1d
--- /dev/null
+++ b/browser/modules/test/unit/test_SiteDataManager.js
@@ -0,0 +1,278 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+// We intend to add tests that add real quota manager data to test
+// data size fetching in the new clear history dialog.
+// Bug 1874387 - Add a test to SiteDataManager to test data size display in the new clear
+// history dialog using real quota manager data
+
+ChromeUtils.defineESModuleGetters(this, {
+  SiteDataManager: "resource:///modules/SiteDataManager.sys.mjs",
+  SiteDataTestUtils: "resource://testing-common/SiteDataTestUtils.sys.mjs",
+  PermissionTestUtils: "resource://testing-common/PermissionTestUtils.sys.mjs",
+});
+
+const EXAMPLE_ORIGIN = "https://www.example.com";
+const EXAMPLE_ORIGIN_2 = "https://example.org";
+const EXAMPLE_ORIGIN_3 = "http://localhost:8000";
+
+let p =
+  Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+    EXAMPLE_ORIGIN
+  );
+let partitionKey = `(${p.scheme},${p.baseDomain})`;
+let EXAMPLE_ORIGIN_2_PARTITIONED =
+  Services.scriptSecurityManager.createContentPrincipal(
+    Services.io.newURI(EXAMPLE_ORIGIN_2),
+    {
+      partitionKey,
+    }
+  ).origin;
+
+add_task(function setup() {
+  do_get_profile();
+});
+
+add_task(async function testGetSites() {
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo1",
+    value: "bar1",
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo2",
+    value: "bar2",
+  });
+
+  // Cookie of EXAMPLE_ORIGIN_2 partitioned under EXAMPLE_ORIGIN.
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2_PARTITIONED,
+    name: "foo3",
+    value: "bar3",
+  });
+  // IndexedDB storage of EXAMPLE_ORIGIN_2 partitioned under EXAMPLE_ORIGIN.
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN, 4096);
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2_PARTITIONED, 4096);
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2,
+    name: "foo",
+    value: "bar",
+  });
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2, 2048);
+  await SiteDataTestUtils.persist(EXAMPLE_ORIGIN_2);
+
+  await SiteDataManager.updateSites();
+
+  let sites = await SiteDataManager.getSites();
+
+  let site1 = sites.find(site => site.baseDomain == "example.com");
+  let site2 = sites.find(site => site.baseDomain == "example.org");
+
+  Assert.equal(
+    site1.baseDomain,
+    "example.com",
+    "Has the correct base domain for example.com"
+  );
+  // 4096 partitioned + 4096 unpartitioned.
+  Assert.greater(site1.usage, 4096 * 2, "Has correct usage for example.com");
+  Assert.equal(site1.persisted, false, "example.com is not persisted");
+  Assert.equal(
+    site1.cookies.length,
+    3, // 2 top level, 1 partitioned.
+    "Has correct number of cookies for example.com"
+  );
+  Assert.ok(
+    typeof site1.lastAccessed.getDate == "function",
+    "lastAccessed for example.com is a Date"
+  );
+  Assert.ok(
+    site1.lastAccessed > Date.now() - 60 * 1000,
+    "lastAccessed for example.com happened recently"
+  );
+
+  Assert.equal(
+    site2.baseDomain,
+    "example.org",
+    "Has the correct base domain for example.org"
+  );
+  Assert.greater(site2.usage, 2048, "Has correct usage for example.org");
+  Assert.equal(site2.persisted, true, "example.org is persisted");
+  Assert.equal(
+    site2.cookies.length,
+    1,
+    "Has correct number of cookies for example.org"
+  );
+  Assert.ok(
+    typeof site2.lastAccessed.getDate == "function",
+    "lastAccessed for example.org is a Date"
+  );
+  Assert.ok(
+    site2.lastAccessed > Date.now() - 60 * 1000,
+    "lastAccessed for example.org happened recently"
+  );
+
+  await SiteDataTestUtils.clear();
+});
+
+add_task(async function testGetTotalUsage() {
+  await SiteDataManager.updateSites();
+  let sites = await SiteDataManager.getSites();
+  Assert.equal(sites.length, 0, "SiteDataManager is empty");
+
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN, 4096);
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2, 2048);
+
+  await SiteDataManager.updateSites();
+
+  let usage = await SiteDataManager.getTotalUsage();
+
+  Assert.greater(usage, 4096 + 2048, "Has the correct total usage.");
+
+  await SiteDataTestUtils.clear();
+});
+
+add_task(async function testRemove() {
+  await SiteDataManager.updateSites();
+
+  let uri = Services.io.newURI(EXAMPLE_ORIGIN);
+  PermissionTestUtils.add(uri, "camera", Services.perms.ALLOW_ACTION);
+
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo1",
+    value: "bar1",
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo2",
+    value: "bar2",
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2_PARTITIONED,
+    name: "foo3",
+    value: "bar3",
+  });
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN, 4096);
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2_PARTITIONED, 4096);
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2,
+    name: "foo",
+    value: "bar",
+  });
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2, 2048);
+  await SiteDataTestUtils.persist(EXAMPLE_ORIGIN_2);
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_3, 2048);
+
+  await SiteDataManager.updateSites();
+
+  let sites = await SiteDataManager.getSites();
+
+  Assert.equal(sites.length, 3, "Has three sites.");
+
+  await SiteDataManager.remove("localhost");
+
+  sites = await SiteDataManager.getSites();
+
+  Assert.equal(sites.length, 2, "Has two sites.");
+
+  await SiteDataManager.remove(["www.example.com"]);
+
+  sites = await SiteDataManager.getSites();
+
+  Assert.equal(sites.length, 1, "Has one site.");
+  Assert.equal(
+    sites[0].baseDomain,
+    "example.org",
+    "Has not cleared data for example.org"
+  );
+
+  let usage = await SiteDataTestUtils.getQuotaUsage(EXAMPLE_ORIGIN);
+  Assert.equal(usage, 0, "Has cleared quota usage for example.com");
+
+  let cookies = Services.cookies.countCookiesFromHost("example.com");
+  Assert.equal(cookies, 0, "Has cleared cookies for example.com");
+
+  let perm = PermissionTestUtils.testPermission(uri, "persistent-storage");
+  Assert.equal(
+    perm,
+    Services.perms.UNKNOWN_ACTION,
+    "Cleared the persistent-storage permission."
+  );
+  perm = PermissionTestUtils.testPermission(uri, "camera");
+  Assert.equal(
+    perm,
+    Services.perms.ALLOW_ACTION,
+    "Did not clear other permissions."
+  );
+
+  PermissionTestUtils.remove(uri, "camera");
+});
+
+add_task(async function testRemoveSiteData() {
+  let uri = Services.io.newURI(EXAMPLE_ORIGIN);
+  PermissionTestUtils.add(uri, "camera", Services.perms.ALLOW_ACTION);
+
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo1",
+    value: "bar1",
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo2",
+    value: "bar2",
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2_PARTITIONED,
+    name: "foo3",
+    value: "bar3",
+  });
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN, 4096);
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2_PARTITIONED, 4096);
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2,
+    name: "foo",
+    value: "bar",
+  });
+  await SiteDataTestUtils.addToIndexedDB(EXAMPLE_ORIGIN_2, 2048);
+  await SiteDataTestUtils.persist(EXAMPLE_ORIGIN_2);
+
+  await SiteDataManager.updateSites();
+
+  let sites = await SiteDataManager.getSites();
+
+  Assert.equal(sites.length, 2, "Has two sites.");
+
+  await SiteDataManager.removeSiteData();
+
+  sites = await SiteDataManager.getSites();
+
+  Assert.equal(sites.length, 0, "Has no sites.");
+
+  let usage = await SiteDataTestUtils.getQuotaUsage(EXAMPLE_ORIGIN);
+  Assert.equal(usage, 0, "Has cleared quota usage for example.com");
+
+  usage = await SiteDataTestUtils.getQuotaUsage(EXAMPLE_ORIGIN_2);
+  Assert.equal(usage, 0, "Has cleared quota usage for example.org");
+
+  let cookies = Services.cookies.countCookiesFromHost("example.org");
+  Assert.equal(cookies, 0, "Has cleared cookies for example.org");
+
+  let perm = PermissionTestUtils.testPermission(uri, "persistent-storage");
+  Assert.equal(
+    perm,
+    Services.perms.UNKNOWN_ACTION,
+    "Cleared the persistent-storage permission."
+  );
+  perm = PermissionTestUtils.testPermission(uri, "camera");
+  Assert.equal(
+    perm,
+    Services.perms.ALLOW_ACTION,
+    "Did not clear other permissions."
+  );
+
+  PermissionTestUtils.remove(uri, "camera");
+});
diff --git a/browser/modules/test/unit/test_SiteDataManagerContainers.js b/browser/modules/test/unit/test_SiteDataManagerContainers.js
new file mode 100644
index 0000000000..18bbb23262
--- /dev/null
+++ b/browser/modules/test/unit/test_SiteDataManagerContainers.js
@@ -0,0 +1,140 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { SiteDataManager } = ChromeUtils.importESModule(
+  "resource:///modules/SiteDataManager.sys.mjs"
+);
+const { SiteDataTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/SiteDataTestUtils.sys.mjs"
+);
+
+const EXAMPLE_ORIGIN = "https://www.example.com";
+const EXAMPLE_ORIGIN_2 = "https://example.org";
+
+add_task(function setup() {
+  do_get_profile();
+});
+
+add_task(async function testGetSitesByContainers() {
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo1",
+    value: "bar1",
+    originAttributes: { userContextId: "1" },
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo2",
+    value: "bar2",
+    originAttributes: { userContextId: "2" },
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN,
+    name: "foo3",
+    value: "bar3",
+    originAttributes: { userContextId: "2" },
+  });
+  SiteDataTestUtils.addToCookies({
+    origin: EXAMPLE_ORIGIN_2,
+    name: "foo",
+    value: "bar",
+    originAttributes: { userContextId: "3" },
+  });
+
+  await SiteDataTestUtils.addToIndexedDB(
+    EXAMPLE_ORIGIN + "^userContextId=1",
+    4096
+  );
+  await SiteDataTestUtils.addToIndexedDB(
+    EXAMPLE_ORIGIN_2 + "^userContextId=3",
+    2048
+  );
+
+  await SiteDataManager.updateSites();
+
+  let sites = await SiteDataManager.getSites();
+
+  let site1Container1 = sites
+    .find(site => site.baseDomain == "example.com")
+    .containersData.get(1);
+
+  let site1Container2 = sites
+    .find(site => site.baseDomain == "example.com")
+    .containersData.get(2);
+
+  let site2Container3 = sites
+    .find(site => site.baseDomain == "example.org")
+    .containersData.get(3);
+
+  Assert.equal(
+    sites.reduce(
+      (accumulator, site) => accumulator + site.containersData.size,
+      0
+    ),
+    3,
+    "Has the correct number of sites by containers"
+  );
+
+  Assert.equal(
+    site1Container1.cookiesBlocked,
+    1,
+    "Has the correct number of cookiesBlocked by containers"
+  );
+
+  Assert.greater(
+    site1Container1.quotaUsage,
+    4096,
+    "Has correct usage for example.com^userContextId=1"
+  );
+
+  Assert.ok(
+    typeof site1Container1.lastAccessed.getDate == "function",
+    "lastAccessed for example.com^userContextId=1 is a Date"
+  );
+  Assert.ok(
+    site1Container1.lastAccessed > Date.now() - 60 * 1000,
+    "lastAccessed for example.com^userContextId=1 happened recently"
+  );
+
+  Assert.equal(
+    site1Container2.cookiesBlocked,
+    2,
+    "Has the correct number of cookiesBlocked by containers"
+  );
+
+  Assert.equal(
+    site1Container2.quotaUsage,
+    0,
+    "Has correct usage for example.org^userContextId=2"
+  );
+
+  Assert.ok(
+    typeof site1Container2.lastAccessed.getDate == "function",
+    "lastAccessed for example.com^userContextId=2 is a Date"
+  );
+
+  Assert.equal(
+    site2Container3.cookiesBlocked,
+    1,
+    "Has the correct number of cookiesBlocked by containers"
+  );
+
+  Assert.greater(
+    site2Container3.quotaUsage,
+    2048,
+    "Has correct usage for example.org^userContextId=3"
+  );
+
+  Assert.ok(
+    typeof site2Container3.lastAccessed.getDate == "function",
+    "lastAccessed for example.org^userContextId=3 is a Date"
+  );
+  Assert.ok(
+    site2Container3.lastAccessed > Date.now() - 60 * 1000,
+    "lastAccessed for example.org^userContextId=3 happened recently"
+  );
+
+  await SiteDataTestUtils.clear();
+});
diff --git a/browser/modules/test/unit/test_SitePermissions.js b/browser/modules/test/unit/test_SitePermissions.js
new file mode 100644
index 0000000000..b5acfbb6f6
--- /dev/null
+++ b/browser/modules/test/unit/test_SitePermissions.js
@@ -0,0 +1,403 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { SitePermissions } = ChromeUtils.importESModule(
+  "resource:///modules/SitePermissions.sys.mjs"
+);
+
+const RESIST_FINGERPRINTING_ENABLED = Services.prefs.getBoolPref(
+  "privacy.resistFingerprinting"
+);
+const MIDI_ENABLED = Services.prefs.getBoolPref("dom.webmidi.enabled");
+
+const EXT_PROTOCOL_ENABLED = Services.prefs.getBoolPref(
+  "security.external_protocol_requires_permission"
+);
+
+const SPEAKER_SELECTION_ENABLED = Services.prefs.getBoolPref(
+  "media.setsinkid.enabled"
+);
+
+add_task(async function testPermissionsListing() {
+  let expectedPermissions = [
+    "autoplay-media",
+    "camera",
+    "cookie",
+    "desktop-notification",
+    "focus-tab-by-prompt",
+    "geo",
+    "install",
+    "microphone",
+    "popup",
+    "screen",
+    "shortcuts",
+    "persistent-storage",
+    "storage-access",
+    "xr",
+    "3rdPartyStorage",
+    "3rdPartyFrameStorage",
+  ];
+  if (RESIST_FINGERPRINTING_ENABLED) {
+    // Canvas permission should be hidden unless privacy.resistFingerprinting
+    // is true.
+    expectedPermissions.push("canvas");
+  }
+  if (MIDI_ENABLED) {
+    // Should remove this checking and add it as default after it is fully pref'd-on.
+    expectedPermissions.push("midi");
+    expectedPermissions.push("midi-sysex");
+  }
+  if (EXT_PROTOCOL_ENABLED) {
+    expectedPermissions.push("open-protocol-handler");
+  }
+  if (SPEAKER_SELECTION_ENABLED) {
+    expectedPermissions.push("speaker");
+  }
+  Assert.deepEqual(
+    SitePermissions.listPermissions().sort(),
+    expectedPermissions.sort(),
+    "Correct list of all permissions"
+  );
+});
+
+add_task(async function testGetAllByPrincipal() {
+  // check that it returns an empty array on an invalid principal
+  // like a principal with an about URI, which doesn't support site permissions
+  let wrongPrincipal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "about:config"
+    );
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(wrongPrincipal), []);
+
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), []);
+
+  SitePermissions.setForPrincipal(principal, "camera", SitePermissions.ALLOW);
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), [
+    {
+      id: "camera",
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+  ]);
+
+  SitePermissions.setForPrincipal(
+    principal,
+    "microphone",
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_SESSION
+  );
+  SitePermissions.setForPrincipal(
+    principal,
+    "desktop-notification",
+    SitePermissions.BLOCK
+  );
+
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), [
+    {
+      id: "camera",
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    {
+      id: "microphone",
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_SESSION,
+    },
+    {
+      id: "desktop-notification",
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+  ]);
+
+  SitePermissions.removeFromPrincipal(principal, "microphone");
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), [
+    {
+      id: "camera",
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    {
+      id: "desktop-notification",
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+  ]);
+
+  SitePermissions.removeFromPrincipal(principal, "camera");
+  SitePermissions.removeFromPrincipal(principal, "desktop-notification");
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), []);
+
+  Assert.equal(Services.prefs.getIntPref("permissions.default.shortcuts"), 0);
+  SitePermissions.setForPrincipal(
+    principal,
+    "shortcuts",
+    SitePermissions.BLOCK
+  );
+
+  // Customized preference should have been enabled, but the default should not.
+  Assert.equal(Services.prefs.getIntPref("permissions.default.shortcuts"), 0);
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), [
+    {
+      id: "shortcuts",
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+  ]);
+
+  SitePermissions.removeFromPrincipal(principal, "shortcuts");
+  Services.prefs.clearUserPref("permissions.default.shortcuts");
+});
+
+add_task(async function testGetAvailableStates() {
+  Assert.deepEqual(SitePermissions.getAvailableStates("camera"), [
+    SitePermissions.UNKNOWN,
+    SitePermissions.ALLOW,
+    SitePermissions.BLOCK,
+  ]);
+
+  // Test available states with a default permission set.
+  Services.prefs.setIntPref(
+    "permissions.default.camera",
+    SitePermissions.ALLOW
+  );
+  Assert.deepEqual(SitePermissions.getAvailableStates("camera"), [
+    SitePermissions.PROMPT,
+    SitePermissions.ALLOW,
+    SitePermissions.BLOCK,
+  ]);
+  Services.prefs.clearUserPref("permissions.default.camera");
+
+  Assert.deepEqual(SitePermissions.getAvailableStates("cookie"), [
+    SitePermissions.ALLOW,
+    SitePermissions.ALLOW_COOKIES_FOR_SESSION,
+    SitePermissions.BLOCK,
+  ]);
+
+  Assert.deepEqual(SitePermissions.getAvailableStates("popup"), [
+    SitePermissions.ALLOW,
+    SitePermissions.BLOCK,
+  ]);
+});
+
+add_task(async function testExactHostMatch() {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+  let subPrincipal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://test1.example.com"
+    );
+
+  let exactHostMatched = [
+    "autoplay-media",
+    "desktop-notification",
+    "focus-tab-by-prompt",
+    "camera",
+    "microphone",
+    "screen",
+    "geo",
+    "xr",
+    "persistent-storage",
+  ];
+  if (RESIST_FINGERPRINTING_ENABLED) {
+    // Canvas permission should be hidden unless privacy.resistFingerprinting
+    // is true.
+    exactHostMatched.push("canvas");
+  }
+  if (MIDI_ENABLED) {
+    // WebMIDI is only pref'd on in nightly.
+    // Should remove this checking and add it as default after it is fully pref-on.
+    exactHostMatched.push("midi");
+    exactHostMatched.push("midi-sysex");
+  }
+  if (EXT_PROTOCOL_ENABLED) {
+    exactHostMatched.push("open-protocol-handler");
+  }
+  if (SPEAKER_SELECTION_ENABLED) {
+    exactHostMatched.push("speaker");
+  }
+  let nonExactHostMatched = [
+    "cookie",
+    "popup",
+    "install",
+    "shortcuts",
+    "storage-access",
+    "3rdPartyStorage",
+    "3rdPartyFrameStorage",
+  ];
+
+  let permissions = SitePermissions.listPermissions();
+  for (let permission of permissions) {
+    SitePermissions.setForPrincipal(
+      principal,
+      permission,
+      SitePermissions.ALLOW
+    );
+
+    if (exactHostMatched.includes(permission)) {
+      // Check that the sub-origin does not inherit the permission from its parent.
+      Assert.equal(
+        SitePermissions.getForPrincipal(subPrincipal, permission).state,
+        SitePermissions.getDefault(permission),
+        `${permission} should exact-host match`
+      );
+    } else if (nonExactHostMatched.includes(permission)) {
+      // Check that the sub-origin does inherit the permission from its parent.
+      Assert.equal(
+        SitePermissions.getForPrincipal(subPrincipal, permission).state,
+        SitePermissions.ALLOW,
+        `${permission} should not exact-host match`
+      );
+    } else {
+      Assert.ok(
+        false,
+        `Found an unknown permission ${permission} in exact host match test.` +
+          "Please add new permissions from SitePermissions.sys.mjs to this test."
+      );
+    }
+
+    // Check that the permission can be made specific to the sub-origin.
+    SitePermissions.setForPrincipal(
+      subPrincipal,
+      permission,
+      SitePermissions.PROMPT
+    );
+    Assert.equal(
+      SitePermissions.getForPrincipal(subPrincipal, permission).state,
+      SitePermissions.PROMPT
+    );
+    Assert.equal(
+      SitePermissions.getForPrincipal(principal, permission).state,
+      SitePermissions.ALLOW
+    );
+
+    SitePermissions.removeFromPrincipal(subPrincipal, permission);
+    SitePermissions.removeFromPrincipal(principal, permission);
+  }
+});
+
+add_task(async function testDefaultPrefs() {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+
+  // Check that without a pref the default return value is UNKNOWN.
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.UNKNOWN,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Check that the default return value changed after setting the pref.
+  Services.prefs.setIntPref(
+    "permissions.default.camera",
+    SitePermissions.BLOCK
+  );
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.BLOCK,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Check that other permissions still return UNKNOWN.
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "microphone"), {
+    state: SitePermissions.UNKNOWN,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Check that the default return value changed after changing the pref.
+  Services.prefs.setIntPref(
+    "permissions.default.camera",
+    SitePermissions.ALLOW
+  );
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Check that the preference is ignored if there is a value.
+  SitePermissions.setForPrincipal(principal, "camera", SitePermissions.BLOCK);
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.BLOCK,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // The preference should be honored again, after resetting the permissions.
+  SitePermissions.removeFromPrincipal(principal, "camera");
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.ALLOW,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+
+  // Should be UNKNOWN after clearing the pref.
+  Services.prefs.clearUserPref("permissions.default.camera");
+  Assert.deepEqual(SitePermissions.getForPrincipal(principal, "camera"), {
+    state: SitePermissions.UNKNOWN,
+    scope: SitePermissions.SCOPE_PERSISTENT,
+  });
+});
+
+add_task(async function testCanvasPermission() {
+  let resistFingerprinting = Services.prefs.getBoolPref(
+    "privacy.resistFingerprinting",
+    false
+  );
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "https://example.com"
+    );
+
+  SitePermissions.setForPrincipal(principal, "canvas", SitePermissions.ALLOW);
+
+  // Canvas permission is hidden when privacy.resistFingerprinting is false.
+  Services.prefs.setBoolPref("privacy.resistFingerprinting", false);
+  Assert.equal(SitePermissions.listPermissions().indexOf("canvas"), -1);
+  Assert.equal(
+    SitePermissions.getAllByPrincipal(principal).filter(
+      permission => permission.id === "canvas"
+    ).length,
+    0
+  );
+
+  // Canvas permission is visible when privacy.resistFingerprinting is true.
+  Services.prefs.setBoolPref("privacy.resistFingerprinting", true);
+  Assert.notEqual(SitePermissions.listPermissions().indexOf("canvas"), -1);
+  Assert.notEqual(
+    SitePermissions.getAllByPrincipal(principal).filter(
+      permission => permission.id === "canvas"
+    ).length,
+    0
+  );
+
+  SitePermissions.removeFromPrincipal(principal, "canvas");
+  Services.prefs.setBoolPref(
+    "privacy.resistFingerprinting",
+    resistFingerprinting
+  );
+});
+
+add_task(async function testFilePermissions() {
+  let principal =
+    Services.scriptSecurityManager.createContentPrincipalFromOrigin(
+      "file:///example.js"
+    );
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), []);
+
+  SitePermissions.setForPrincipal(principal, "camera", SitePermissions.ALLOW);
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), [
+    {
+      id: "camera",
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+  ]);
+  SitePermissions.removeFromPrincipal(principal, "camera");
+  Assert.deepEqual(SitePermissions.getAllByPrincipal(principal), []);
+});
diff --git a/browser/modules/test/unit/test_SitePermissions_temporary.js b/browser/modules/test/unit/test_SitePermissions_temporary.js
new file mode 100644
index 0000000000..a91b1b8bd8
--- /dev/null
+++ b/browser/modules/test/unit/test_SitePermissions_temporary.js
@@ -0,0 +1,710 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { SitePermissions } = ChromeUtils.importESModule(
+  "resource:///modules/SitePermissions.sys.mjs"
+);
+
+const TemporaryPermissions = SitePermissions._temporaryPermissions;
+
+const PERM_A = "foo";
+const PERM_B = "bar";
+const PERM_C = "foobar";
+
+const BROWSER_A = createDummyBrowser("https://example.com/foo");
+const BROWSER_B = createDummyBrowser("https://example.org/foo");
+
+const EXPIRY_MS_A = 1000000;
+const EXPIRY_MS_B = 1000001;
+
+function createDummyBrowser(spec) {
+  let uri = Services.io.newURI(spec);
+  return {
+    currentURI: uri,
+    contentPrincipal: Services.scriptSecurityManager.createContentPrincipal(
+      uri,
+      {}
+    ),
+    dispatchEvent: () => {},
+    ownerGlobal: {
+      CustomEvent: class CustomEvent {},
+    },
+  };
+}
+
+function navigateDummyBrowser(browser, uri) {
+  // Callers may pass in either uri strings or nsIURI objects.
+  if (typeof uri == "string") {
+    uri = Services.io.newURI(uri);
+  }
+  browser.currentURI = uri;
+  browser.contentPrincipal =
+    Services.scriptSecurityManager.createContentPrincipal(
+      browser.currentURI,
+      {}
+    );
+}
+
+/**
+ * Tests that temporary permissions with different block states are stored
+ * (set, overwrite, delete) correctly.
+ */
+add_task(async function testAllowBlock() {
+  // Set two temporary permissions on the same browser.
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_B,
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+
+  // Test that the permissions have been set correctly.
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, BROWSER_A),
+    {
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "SitePermissions returns expected permission state for perm A."
+  );
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_B, BROWSER_A),
+    {
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "SitePermissions returns expected permission state for perm B."
+  );
+
+  Assert.deepEqual(
+    TemporaryPermissions.get(BROWSER_A, PERM_A),
+    {
+      id: PERM_A,
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "TemporaryPermissions returns expected permission state for perm A."
+  );
+
+  Assert.deepEqual(
+    TemporaryPermissions.get(BROWSER_A, PERM_B),
+    {
+      id: PERM_B,
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "TemporaryPermissions returns expected permission state for perm B."
+  );
+
+  // Test internal data structure of TemporaryPermissions.
+  let entry = TemporaryPermissions._stateByBrowser.get(BROWSER_A);
+  ok(entry, "Should have an entry for browser A");
+  ok(
+    !TemporaryPermissions._stateByBrowser.has(BROWSER_B),
+    "Should have no entry for browser B"
+  );
+
+  let { browser, uriToPerm } = entry;
+  Assert.equal(
+    browser?.get(),
+    BROWSER_A,
+    "Entry should have a weak reference to the browser."
+  );
+
+  ok(uriToPerm, "Entry should have uriToPerm object.");
+  Assert.equal(Object.keys(uriToPerm).length, 2, "uriToPerm has 2 entries.");
+
+  let permissionsA = uriToPerm[BROWSER_A.contentPrincipal.origin];
+  let permissionsB =
+    uriToPerm[Services.eTLD.getBaseDomain(BROWSER_A.currentURI)];
+
+  ok(permissionsA, "Allow should be keyed under origin");
+  ok(permissionsB, "Block should be keyed under baseDomain");
+
+  let permissionA = permissionsA[PERM_A];
+  let permissionB = permissionsB[PERM_B];
+
+  Assert.equal(
+    permissionA.state,
+    SitePermissions.ALLOW,
+    "Should have correct state"
+  );
+  let expireTimeoutA = permissionA.expireTimeout;
+  Assert.ok(
+    Number.isInteger(expireTimeoutA),
+    "Should have valid expire timeout"
+  );
+
+  Assert.equal(
+    permissionB.state,
+    SitePermissions.BLOCK,
+    "Should have correct state"
+  );
+  let expireTimeoutB = permissionB.expireTimeout;
+  Assert.ok(
+    Number.isInteger(expireTimeoutB),
+    "Should have valid expire timeout"
+  );
+
+  // Overwrite permission A.
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_B
+  );
+
+  Assert.ok(
+    permissionsA[PERM_A].expireTimeout != expireTimeoutA,
+    "Overwritten permission A should have new timer"
+  );
+
+  // Overwrite permission B - this time with a non-block state which means it
+  // should be keyed by origin now.
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_B,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+
+  let baseDomainEntry =
+    uriToPerm[Services.eTLD.getBaseDomain(BROWSER_A.currentURI)];
+  Assert.ok(
+    !baseDomainEntry || !baseDomainEntry[PERM_B],
+    "Should not longer have baseDomain permission entry"
+  );
+
+  permissionsB = uriToPerm[BROWSER_A.contentPrincipal.origin];
+  permissionB = permissionsB[PERM_B];
+  Assert.ok(
+    permissionsB && permissionB,
+    "Overwritten permission should be keyed under origin"
+  );
+  Assert.equal(
+    permissionB.state,
+    SitePermissions.ALLOW,
+    "Should have correct updated state"
+  );
+  Assert.ok(
+    permissionB.expireTimeout != expireTimeoutB,
+    "Overwritten permission B should have new timer"
+  );
+
+  // Remove permissions
+  SitePermissions.removeFromPrincipal(null, PERM_A, BROWSER_A);
+  SitePermissions.removeFromPrincipal(null, PERM_B, BROWSER_A);
+
+  // Test that permissions have been removed correctly
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, BROWSER_A),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "SitePermissions returns UNKNOWN state for A."
+  );
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_B, BROWSER_A),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "SitePermissions returns UNKNOWN state for B."
+  );
+
+  Assert.equal(
+    TemporaryPermissions.get(BROWSER_A, PERM_A),
+    null,
+    "TemporaryPermissions returns null for perm A."
+  );
+
+  Assert.equal(
+    TemporaryPermissions.get(BROWSER_A, PERM_B),
+    null,
+    "TemporaryPermissions returns null for perm B."
+  );
+});
+
+/**
+ * Tests TemporaryPermissions#getAll.
+ */
+add_task(async function testGetAll() {
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_B,
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_B,
+    EXPIRY_MS_A
+  );
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_C,
+    SitePermissions.PROMPT,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_B,
+    EXPIRY_MS_A
+  );
+
+  Assert.deepEqual(TemporaryPermissions.getAll(BROWSER_A), [
+    {
+      id: PERM_A,
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+  ]);
+
+  let permsBrowserB = TemporaryPermissions.getAll(BROWSER_B);
+  Assert.equal(
+    permsBrowserB.length,
+    2,
+    "There should be 2 permissions set for BROWSER_B"
+  );
+
+  let permB;
+  let permC;
+
+  if (permsBrowserB[0].id == PERM_B) {
+    permB = permsBrowserB[0];
+    permC = permsBrowserB[1];
+  } else {
+    permB = permsBrowserB[1];
+    permC = permsBrowserB[0];
+  }
+
+  Assert.deepEqual(permB, {
+    id: PERM_B,
+    state: SitePermissions.BLOCK,
+    scope: SitePermissions.SCOPE_TEMPORARY,
+  });
+  Assert.deepEqual(permC, {
+    id: PERM_C,
+    state: SitePermissions.PROMPT,
+    scope: SitePermissions.SCOPE_TEMPORARY,
+  });
+});
+
+/**
+ * Tests SitePermissions#clearTemporaryBlockPermissions and
+ * TemporaryPermissions#clear.
+ */
+add_task(async function testClear() {
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_B,
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_A
+  );
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_C,
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_B,
+    EXPIRY_MS_A
+  );
+
+  let stateByBrowser = SitePermissions._temporaryPermissions._stateByBrowser;
+
+  Assert.ok(stateByBrowser.has(BROWSER_A), "Browser map should have BROWSER_A");
+  Assert.ok(stateByBrowser.has(BROWSER_B), "Browser map should have BROWSER_B");
+
+  SitePermissions.clearTemporaryBlockPermissions(BROWSER_A);
+
+  // We only clear block permissions, so we should still see PERM_A.
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, BROWSER_A),
+    {
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "SitePermissions returns ALLOW state for PERM_A."
+  );
+  // We don't clear BROWSER_B so it should still be there.
+  Assert.ok(stateByBrowser.has(BROWSER_B), "Should still have BROWSER_B.");
+
+  // Now clear allow permissions for A explicitly.
+  SitePermissions._temporaryPermissions.clear(BROWSER_A, SitePermissions.ALLOW);
+
+  Assert.ok(!stateByBrowser.has(BROWSER_A), "Should no longer have BROWSER_A.");
+  let browser = stateByBrowser.get(BROWSER_B);
+  Assert.ok(browser, "Should still have BROWSER_B");
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, BROWSER_A),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "SitePermissions returns UNKNOWN state for PERM_A."
+  );
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_B, BROWSER_A),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "SitePermissions returns UNKNOWN state for PERM_B."
+  );
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_C, BROWSER_B),
+    {
+      state: SitePermissions.BLOCK,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "SitePermissions returns BLOCK state for PERM_C."
+  );
+
+  SitePermissions._temporaryPermissions.clear(BROWSER_B);
+
+  Assert.ok(!stateByBrowser.has(BROWSER_B), "Should no longer have BROWSER_B.");
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_C, BROWSER_B),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "SitePermissions returns UNKNOWN state for PERM_C."
+  );
+});
+
+/**
+ * Tests that the temporary permissions setter calls the callback on permission
+ * expire with the associated browser.
+ */
+add_task(async function testCallbackOnExpiry() {
+  let promiseExpireA = new Promise(resolve => {
+    TemporaryPermissions.set(
+      BROWSER_A,
+      PERM_A,
+      SitePermissions.BLOCK,
+      100,
+      undefined,
+      resolve
+    );
+  });
+  let promiseExpireB = new Promise(resolve => {
+    TemporaryPermissions.set(
+      BROWSER_B,
+      PERM_A,
+      SitePermissions.BLOCK,
+      100,
+      BROWSER_B.contentPrincipal,
+      resolve
+    );
+  });
+
+  let [browserA, browserB] = await Promise.all([
+    promiseExpireA,
+    promiseExpireB,
+  ]);
+  Assert.equal(
+    browserA,
+    BROWSER_A,
+    "Should get callback with browser on expiry for A"
+  );
+  Assert.equal(
+    browserB,
+    BROWSER_B,
+    "Should get callback with browser on expiry for B"
+  );
+});
+
+/**
+ * Tests that the temporary permissions setter calls the callback on permission
+ * expire with the associated browser if the browser associated browser has
+ * changed after setting the permission.
+ */
+add_task(async function testCallbackOnExpiryUpdatedBrowser() {
+  let promiseExpire = new Promise(resolve => {
+    TemporaryPermissions.set(
+      BROWSER_A,
+      PERM_A,
+      SitePermissions.BLOCK,
+      200,
+      undefined,
+      resolve
+    );
+  });
+
+  TemporaryPermissions.copy(BROWSER_A, BROWSER_B);
+
+  let browser = await promiseExpire;
+  Assert.equal(
+    browser,
+    BROWSER_B,
+    "Should get callback with updated browser on expiry."
+  );
+});
+
+/**
+ * Tests that the permission setter throws an exception if an invalid expiry
+ * time is passed.
+ */
+add_task(async function testInvalidExpiryTime() {
+  let expectedError = /expireTime must be a positive integer/;
+  Assert.throws(() => {
+    SitePermissions.setForPrincipal(
+      null,
+      PERM_A,
+      SitePermissions.ALLOW,
+      SitePermissions.SCOPE_TEMPORARY,
+      BROWSER_A,
+      null
+    );
+  }, expectedError);
+  Assert.throws(() => {
+    SitePermissions.setForPrincipal(
+      null,
+      PERM_A,
+      SitePermissions.ALLOW,
+      SitePermissions.SCOPE_TEMPORARY,
+      BROWSER_A,
+      0
+    );
+  }, expectedError);
+  Assert.throws(() => {
+    SitePermissions.setForPrincipal(
+      null,
+      PERM_A,
+      SitePermissions.ALLOW,
+      SitePermissions.SCOPE_TEMPORARY,
+      BROWSER_A,
+      -100
+    );
+  }, expectedError);
+});
+
+/**
+ * Tests that we block by base domain but allow by origin.
+ */
+add_task(async function testTemporaryPermissionScope() {
+  let states = {
+    strict: {
+      same: [
+        "https://example.com",
+        "https://example.com/sub/path",
+        "https://example.com:443",
+        "https://name:password@example.com",
+      ],
+      different: [
+        "https://example.com",
+        "https://test1.example.com",
+        "http://example.com",
+        "http://example.org",
+        "file:///tmp/localPageA.html",
+        "file:///tmp/localPageB.html",
+      ],
+    },
+    nonStrict: {
+      same: [
+        "https://example.com",
+        "https://example.com/sub/path",
+        "https://example.com:443",
+        "https://test1.example.com",
+        "http://test2.test1.example.com",
+        "https://name:password@example.com",
+        "http://example.com",
+      ],
+      different: [
+        "https://example.com",
+        "https://example.org",
+        "http://example.net",
+      ],
+    },
+  };
+
+  for (let state of [SitePermissions.BLOCK, SitePermissions.ALLOW]) {
+    let matchStrict = state != SitePermissions.BLOCK;
+
+    let lists = matchStrict ? states.strict : states.nonStrict;
+
+    Object.entries(lists).forEach(([type, list]) => {
+      let expectSet = type == "same";
+
+      for (let uri of list) {
+        let browser = createDummyBrowser(uri);
+        SitePermissions.setForPrincipal(
+          null,
+          PERM_A,
+          state,
+          SitePermissions.SCOPE_TEMPORARY,
+          browser,
+          EXPIRY_MS_A
+        );
+
+        ok(true, "origin:" + browser.contentPrincipal.origin);
+
+        for (let otherUri of list) {
+          if (uri == otherUri) {
+            continue;
+          }
+          navigateDummyBrowser(browser, otherUri);
+          ok(true, "new origin:" + browser.contentPrincipal.origin);
+
+          Assert.deepEqual(
+            SitePermissions.getForPrincipal(null, PERM_A, browser),
+            {
+              state: expectSet ? state : SitePermissions.UNKNOWN,
+              scope: expectSet
+                ? SitePermissions.SCOPE_TEMPORARY
+                : SitePermissions.SCOPE_PERSISTENT,
+            },
+            `${
+              state == SitePermissions.BLOCK ? "Block" : "Allow"
+            } Permission originally set for ${uri} should ${
+              expectSet ? "not" : "also"
+            } be set for ${otherUri}.`
+          );
+        }
+
+        SitePermissions._temporaryPermissions.clear(browser);
+      }
+    });
+  }
+});
+
+/**
+ * Tests that we can override the principal to use for keying temporary
+ * permissions.
+ */
+add_task(async function testOverrideBrowserURI() {
+  let testBrowser = createDummyBrowser("https://old.example.com/foo");
+  let overrideURI = Services.io.newURI("https://test.example.org/test/path");
+  SitePermissions.setForPrincipal(
+    Services.scriptSecurityManager.createContentPrincipal(overrideURI, {}),
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    testBrowser,
+    EXPIRY_MS_A
+  );
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, testBrowser),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "Permission should not be set for old URI."
+  );
+
+  // "Navigate" to new URI
+  navigateDummyBrowser(testBrowser, overrideURI);
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, testBrowser),
+    {
+      state: SitePermissions.ALLOW,
+      scope: SitePermissions.SCOPE_TEMPORARY,
+    },
+    "Permission should be set for new URI."
+  );
+
+  SitePermissions._temporaryPermissions.clear(testBrowser);
+});
+
+/**
+ * Tests that TemporaryPermissions does not throw for incompatible URI or
+ * browser.currentURI.
+ */
+add_task(async function testPermissionUnsupportedScheme() {
+  let aboutURI = Services.io.newURI("about:blank");
+
+  // Incompatible override URI should not throw or store any permissions.
+  SitePermissions.setForPrincipal(
+    Services.scriptSecurityManager.createContentPrincipal(aboutURI, {}),
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    BROWSER_A,
+    EXPIRY_MS_B
+  );
+  Assert.ok(
+    SitePermissions._temporaryPermissions._stateByBrowser.has(BROWSER_A),
+    "Should not have stored permission for unsupported URI scheme."
+  );
+
+  let browser = createDummyBrowser("https://example.com/");
+  // Set a permission so we get an entry in the browser map.
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_B,
+    SitePermissions.BLOCK,
+    SitePermissions.SCOPE_TEMPORARY,
+    browser
+  );
+
+  // Change browser URI to about:blank.
+  navigateDummyBrowser(browser, aboutURI);
+
+  // Setting permission for browser with unsupported URI should not throw.
+  SitePermissions.setForPrincipal(
+    null,
+    PERM_A,
+    SitePermissions.ALLOW,
+    SitePermissions.SCOPE_TEMPORARY,
+    browser
+  );
+  Assert.ok(true, "Set should not throw for unsupported URI");
+
+  SitePermissions.removeFromPrincipal(null, PERM_A, browser);
+  Assert.ok(true, "Remove should not throw for unsupported URI");
+
+  Assert.deepEqual(
+    SitePermissions.getForPrincipal(null, PERM_A, browser),
+    {
+      state: SitePermissions.UNKNOWN,
+      scope: SitePermissions.SCOPE_PERSISTENT,
+    },
+    "Should return no permission set for unsupported URI."
+  );
+  Assert.ok(true, "Get should not throw for unsupported URI");
+
+  // getAll should not throw, but return empty permissions array.
+  let permissions = SitePermissions.getAllForBrowser(browser);
+  Assert.ok(
+    Array.isArray(permissions) && !permissions.length,
+    "Should return empty array for browser on about:blank"
+  );
+
+  SitePermissions._temporaryPermissions.clear(browser);
+});
diff --git a/browser/modules/test/unit/test_TabUnloader.js b/browser/modules/test/unit/test_TabUnloader.js
new file mode 100644
index 0000000000..3d125828bb
--- /dev/null
+++ b/browser/modules/test/unit/test_TabUnloader.js
@@ -0,0 +1,449 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+"use strict";
+
+const { TabUnloader } = ChromeUtils.importESModule(
+  "resource:///modules/TabUnloader.sys.mjs"
+);
+
+let TestTabUnloaderMethods = {
+  isNonDiscardable(tab, weight) {
+    return /\bselected\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  isParentProcess(tab, weight) {
+    return /\bparent\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  isPinned(tab, weight) {
+    return /\bpinned\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  isLoading(tab, weight) {
+    return /\bloading\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  usingPictureInPicture(tab, weight) {
+    return /\bpictureinpicture\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  playingMedia(tab, weight) {
+    return /\bmedia\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  usingWebRTC(tab, weight) {
+    return /\bwebrtc\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  isPrivate(tab, weight) {
+    return /\bprivate\b/.test(tab.keywords) ? weight : 0;
+  },
+
+  getMinTabCount() {
+    // Use a low number for testing.
+    return 3;
+  },
+
+  getNow() {
+    return 100;
+  },
+
+  *iterateProcesses(tab) {
+    for (let process of tab.process.split(",")) {
+      yield Number(process);
+    }
+  },
+
+  async calculateMemoryUsage(processMap, tabs) {
+    let memory = tabs[0].memory;
+    for (let pid of processMap.keys()) {
+      processMap.get(pid).memory = memory ? memory[pid - 1] : 1;
+    }
+  },
+};
+
+let unloadTests = [
+  // Each item in the array represents one test. The test is a subarray
+  // containing an element per tab. This is a string of keywords that
+  // identify which criteria apply. The first part of the string may contain
+  // a number that represents the last visit time, where higher numbers
+  // are later. The last element in the subarray is special and identifies
+  // the expected order of the tabs sorted by weight. The first tab in
+  // this list is the one that is expected to selected to be discarded.
+  { tabs: ["1 selected", "2", "3"], result: "1,2,0" },
+  { tabs: ["1", "2 selected", "3"], result: "0,2,1" },
+  { tabs: ["1 selected", "2", "3"], process: ["1", "2", "3"], result: "1,2,0" },
+  {
+    tabs: ["1 selected", "2 selected", "3 selected"],
+    process: ["1", "2", "3"],
+    result: "0,1,2",
+  },
+  {
+    tabs: ["1 selected", "2", "3"],
+    process: ["1,2,3", "2", "3"],
+    result: "1,2,0",
+  },
+  {
+    tabs: ["9", "8", "6", "5 selected", "2", "3", "4", "1"],
+    result: "7,4,5,6,2,1,0,3",
+  },
+  {
+    tabs: ["9", "8 pinned", "6", "5 selected", "2", "3 pinned", "4", "1"],
+    result: "7,4,6,2,0,5,1,3",
+  },
+  {
+    tabs: [
+      "9",
+      "8 pinned",
+      "6",
+      "5 selected pinned",
+      "2",
+      "3 pinned",
+      "4",
+      "1",
+    ],
+    result: "7,4,6,2,0,5,1,3",
+  },
+  {
+    tabs: [
+      "9",
+      "8 pinned",
+      "6",
+      "5 selected pinned",
+      "2",
+      "3 selected pinned",
+      "4",
+      "1",
+    ],
+    result: "7,4,6,2,0,1,5,3",
+  },
+  {
+    tabs: ["1", "2 selected", "3", "4 media", "5", "6"],
+    result: "0,2,4,5,1,3",
+  },
+  {
+    tabs: ["1 media", "2 selected media", "3", "4 media", "5", "6"],
+    result: "2,4,5,0,3,1",
+  },
+  {
+    tabs: ["1 media", "2 media pinned", "3", "4 media", "5 pinned", "6"],
+    result: "2,5,4,0,3,1",
+  },
+  {
+    tabs: [
+      "1 media",
+      "2 media pinned",
+      "3",
+      "4 media",
+      "5 media pinned",
+      "6 selected",
+    ],
+    result: "2,0,3,5,1,4",
+  },
+  {
+    tabs: [
+      "10 selected",
+      "20 private",
+      "30 webrtc",
+      "40 pictureinpicture",
+      "50 loading pinned",
+      "60",
+    ],
+    result: "5,4,0,1,2,3",
+  },
+  {
+    // Since TestTabUnloaderMethods.getNow() returns 100 and the test
+    // passes minInactiveDuration = 0 to TabUnloader.getSortedTabs(),
+    // tab 200 and 300 are excluded from the result.
+    tabs: ["300", "10", "50", "100", "200"],
+    result: "1,2,3",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1", "2", "1", "1", "1", "1"],
+    result: "1,0,2,3,4,5",
+  },
+  {
+    tabs: ["1", "2 selected", "3", "4", "5", "6"],
+    process: ["1", "2", "1", "1", "1", "1"],
+    result: "0,2,3,4,5,1",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1", "2", "2", "1", "1", "1"],
+    result: "0,1,2,3,4,5",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1", "2", "3", "1", "1", "1"],
+    result: "1,0,2,3,4,5",
+  },
+  {
+    tabs: ["1", "2 media", "3", "4", "5", "6"],
+    process: ["1", "2", "3", "1", "1", "1"],
+    result: "2,0,3,4,5,1",
+  },
+  {
+    tabs: ["1", "2 media", "3", "4", "5", "6"],
+    process: ["1", "2", "3", "1", "1,2,3", "1"],
+    result: "0,2,3,4,5,1",
+  },
+  {
+    tabs: ["1", "2 media", "3", "4", "5", "6"],
+    process: ["1", "2", "3", "1", "1,4,5", "1"],
+    result: "2,0,3,4,5,1",
+  },
+  {
+    tabs: ["1", "2 media", "3 media", "4", "5 media", "6"],
+    process: ["1", "2", "3", "1", "1,4,5", "1"],
+    result: "0,3,5,1,2,4",
+  },
+  {
+    tabs: ["1", "2 media", "3 media", "4", "5 media", "6"],
+    process: ["1", "1", "3", "1", "1,4,5", "1"],
+    result: "0,3,5,1,2,4",
+  },
+  {
+    tabs: ["1", "2 media", "3 media", "4", "5 media", "6"],
+    process: ["1", "2", "3", "4", "1,4,5", "5"],
+    result: "0,3,5,1,2,4",
+  },
+  {
+    tabs: ["1", "2 media", "3 media", "4", "5 media", "6"],
+    process: ["1", "1", "3", "4", "1,4,5", "5"],
+    result: "0,3,5,1,2,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1", "1", "1", "2", "1,3,4,5,6,7,8", "1"],
+    result: "0,1,2,3,4,5",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1", "1", "1", "2", "1,3,4,5,6,7,8", "1", "1", "1"],
+    result: "4,0,3,1,2,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 selected", "6"],
+    process: ["1", "1", "1", "2", "1,3,4,5,6,7,8", "1"],
+    result: "0,1,2,3,5,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6"],
+    process: ["1", "1", "1", "2", "1,3,4,5,6,7,8", "1"],
+    result: "0,1,2,3,5,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1", "2", "1,3,4,5,6,7,8", "1", "1", "1"],
+    result: "0,3,1,2,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1,3,4,5,6,7,8", "1", "1", "1", "1", "1", "1"],
+    result: "1,0,2,3,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1,3,4,5,6,7,8", "1", "1", "1", "1", "1"],
+    result: "2,0,1,3,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1,1,1,1,1,1,1", "1", "1", "1", "1,1,1,1,1", "1"],
+    result: "0,1,2,3,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1,2,3,4,5", "1", "1", "1", "1,2,3,4,5", "1"],
+    result: "0,1,2,3,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1,6", "1", "1", "1", "1,2,3,4,5", "1"],
+    result: "0,2,1,3,5,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1", "1", "1,6", "1,7", "1,8", "1,9", "1,2,3,4,5", "1"],
+    result: "2,3,0,5,1,6,7,4",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5 media", "6", "7", "8"],
+    process: ["1,10,11", "1", "1,2", "1,7", "1,8", "1,9", "1,2,3,4,5", "1"],
+    result: "0,3,1,5,2,6,7,4",
+  },
+  {
+    tabs: [
+      "1 media",
+      "2 media",
+      "3 media",
+      "4 media",
+      "5 media",
+      "6",
+      "7",
+      "8",
+    ],
+    process: ["1,10,11", "1", "1,2", "1,7", "1,8", "1,9", "1,2,3,4,5", "1"],
+    result: "6,5,7,0,1,2,3,4",
+  },
+  {
+    tabs: ["1", "2", "3"],
+    process: ["1", "2", "3"],
+    memory: ["100", "200", "300"],
+    result: "0,1,2",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    process: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    memory: [
+      "100",
+      "200",
+      "300",
+      "400",
+      "500",
+      "600",
+      "700",
+      "800",
+      "900",
+      "1000",
+    ],
+    result: "0,1,2,3,4,5,6,7,8,9",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    process: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    memory: [
+      "100",
+      "900",
+      "300",
+      "500",
+      "400",
+      "700",
+      "600",
+      "1000",
+      "200",
+      "200",
+    ],
+    result: "1,0,2,3,5,4,6,7,8,9",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    process: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+    memory: [
+      "1000",
+      "900",
+      "300",
+      "500",
+      "400",
+      "1000",
+      "600",
+      "1000",
+      "200",
+      "200",
+    ],
+    result: "0,1,2,3,5,4,6,7,8,9",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1", "2,7", "3", "4", "5", "6"],
+    memory: ["100", "200", "300", "400", "500", "600", "700"],
+    result: "1,0,2,3,4,5",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1,6", "2,7", "3,8", "4,1,2", "5", "6", "7", "8"],
+    memory: ["100", "200", "300", "400", "500", "600", "700", "800"],
+    result: "2,3,0,1,4,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1", "1", "1", "2", "1", "1", "1", "1"],
+    memory: ["700", "1000"],
+    result: "0,3,1,2,4,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1", "1", "1", "1", "2,1", "2,1", "3", "3"],
+    memory: ["1000", "2000", "3000"],
+    result: "0,1,2,4,3,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["2", "2", "2", "2", "2,1", "2,1", "3", "3"],
+    memory: ["1000", "600", "1000"],
+    result: "0,1,2,4,3,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1", "1", "1", "2", "2,1,1,1", "2,1", "3", "3"],
+    memory: ["1000", "1800", "1000"],
+    result: "0,1,3,2,4,5,6,7",
+  },
+  {
+    tabs: ["1", "2", "3", "4", "5", "6", "7", "8"],
+    process: ["1", "1", "1", "2", "2,1,1,1", "2,1", "3", "3"],
+    memory: ["4000", "1800", "1000"],
+    result: "0,1,2,4,3,5,6,7",
+  },
+  {
+    // The tab "1" contains 4 frames, but its uniqueCount is 1 because
+    // all of those frames are backed by the process "1".  As a result,
+    // TabUnloader puts the tab "1" first based on the last access time.
+    tabs: ["1", "2", "3", "4", "5"],
+    process: ["1,1,1,1", "2", "3", "3", "3"],
+    memory: ["100", "100", "100"],
+    result: "0,1,2,3,4",
+  },
+  {
+    // The uniqueCount of the tab "1", "2", and "3" is 1, 2, and 3,
+    // respectively.  As a result the first three tabs are sorted as 2,1,0.
+    tabs: ["1", "2", "3", "4", "5", "6"],
+    process: ["1,7,1,7,1,1,7,1", "7,3,7,2", "4,5,7,4,6,7", "7", "7", "7"],
+    memory: ["100", "100", "100", "100", "100", "100", "100"],
+    result: "2,1,0,3,4,5",
+  },
+];
+
+let globalBrowser = {
+  discardBrowser() {
+    return true;
+  },
+};
+
+add_task(async function doTests() {
+  for (let test of unloadTests) {
+    function* iterateTabs() {
+      let tabs = test.tabs;
+      for (let t = 0; t < tabs.length; t++) {
+        let tab = {
+          tab: {
+            originalIndex: t,
+            lastAccessed: Number(/^[0-9]+/.exec(tabs[t])[0]),
+            keywords: tabs[t],
+            process: "process" in test ? test.process[t] : "1",
+          },
+          memory: test.memory,
+          gBrowser: globalBrowser,
+        };
+        yield tab;
+      }
+    }
+    TestTabUnloaderMethods.iterateTabs = iterateTabs;
+
+    let expectedOrder = "";
+    const sortedTabs = await TabUnloader.getSortedTabs(
+      0,
+      TestTabUnloaderMethods
+    );
+    for (let tab of sortedTabs) {
+      if (expectedOrder) {
+        expectedOrder += ",";
+      }
+      expectedOrder += tab.tab.originalIndex;
+    }
+
+    Assert.equal(expectedOrder, test.result);
+  }
+});
diff --git a/browser/modules/test/unit/test_discovery.js b/browser/modules/test/unit/test_discovery.js
new file mode 100644
index 0000000000..08f67273a6
--- /dev/null
+++ b/browser/modules/test/unit/test_discovery.js
@@ -0,0 +1,143 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+"use strict";
+
+// ClientID fails without...
+do_get_profile();
+
+const { TestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TestUtils.sys.mjs"
+);
+const { ClientID } = ChromeUtils.importESModule(
+  "resource://gre/modules/ClientID.sys.mjs"
+);
+const { Discovery } = ChromeUtils.importESModule(
+  "resource:///modules/Discovery.sys.mjs"
+);
+const { ContextualIdentityService } = ChromeUtils.importESModule(
+  "resource://gre/modules/ContextualIdentityService.sys.mjs"
+);
+
+const TAAR_COOKIE_NAME = "taarId";
+
+add_task(async function test_discovery() {
+  let uri = Services.io.newURI("https://example.com/foobar");
+
+  // Ensure the prefs we need
+  Services.prefs.setBoolPref("browser.discovery.enabled", true);
+  Services.prefs.setBoolPref("browser.discovery.containers.enabled", true);
+  Services.prefs.setBoolPref("datareporting.healthreport.uploadEnabled", true);
+  Services.prefs.setCharPref("browser.discovery.sites", uri.host);
+
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref("browser.discovery.enabled");
+    Services.prefs.clearUserPref("browser.discovery.containers.enabled");
+    Services.prefs.clearUserPref("browser.discovery.sites");
+    Services.prefs.clearUserPref("datareporting.healthreport.uploadEnabled");
+  });
+
+  // This is normally initialized by telemetry, force id creation.  This results
+  // in Discovery setting the cookie.
+  await ClientID.getClientID();
+  await Discovery.update();
+
+  ok(
+    Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {}),
+    "cookie exists"
+  );
+  ok(
+    !Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {
+      privateBrowsingId: 1,
+    }),
+    "no private cookie exists"
+  );
+  ContextualIdentityService.getPublicIdentities().forEach(identity => {
+    let { userContextId } = identity;
+    equal(
+      Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {
+        userContextId,
+      }),
+      identity.public,
+      "cookie exists"
+    );
+  });
+
+  // Test the addition of a new container.
+  let changed = TestUtils.topicObserved("cookie-changed", subject => {
+    let cookie = subject
+      .QueryInterface(Ci.nsICookieNotification)
+      .cookie.QueryInterface(Ci.nsICookie);
+    equal(cookie.name, TAAR_COOKIE_NAME, "taar cookie exists");
+    equal(cookie.host, uri.host, "cookie exists for host");
+    equal(
+      cookie.originAttributes.userContextId,
+      container.userContextId,
+      "cookie userContextId is correct"
+    );
+    return true;
+  });
+  let container = ContextualIdentityService.create(
+    "New Container",
+    "Icon",
+    "Color"
+  );
+  await changed;
+
+  // Test disabling
+  Discovery.enabled = false;
+  // Wait for the update to remove the cookie.
+  await TestUtils.waitForCondition(() => {
+    return !Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {});
+  });
+
+  ContextualIdentityService.getPublicIdentities().forEach(identity => {
+    let { userContextId } = identity;
+    ok(
+      !Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {
+        userContextId,
+      }),
+      "no cookie exists"
+    );
+  });
+
+  // turn off containers
+  Services.prefs.setBoolPref("browser.discovery.containers.enabled", false);
+
+  Discovery.enabled = true;
+  await TestUtils.waitForCondition(() => {
+    return Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {});
+  });
+  // make sure we did not set cookies on containers
+  ContextualIdentityService.getPublicIdentities().forEach(identity => {
+    let { userContextId } = identity;
+    ok(
+      !Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {
+        userContextId,
+      }),
+      "no cookie exists"
+    );
+  });
+
+  // Make sure clientId changes update discovery
+  changed = TestUtils.topicObserved("cookie-changed", subject => {
+    let notification = subject.QueryInterface(Ci.nsICookieNotification);
+    if (notification.action != Ci.nsICookieNotification.COOKIE_ADDED) {
+      return false;
+    }
+    let cookie = notification.cookie.QueryInterface(Ci.nsICookie);
+    equal(cookie.name, TAAR_COOKIE_NAME, "taar cookie exists");
+    equal(cookie.host, uri.host, "cookie exists for host");
+    return true;
+  });
+  await ClientID.removeClientID();
+  await ClientID.getClientID();
+  await changed;
+
+  // Make sure disabling telemetry disables discovery.
+  Services.prefs.setBoolPref("datareporting.healthreport.uploadEnabled", false);
+  await TestUtils.waitForCondition(() => {
+    return !Services.cookies.cookieExists(uri.host, "/", TAAR_COOKIE_NAME, {});
+  });
+});
diff --git a/browser/modules/test/unit/xpcshell.toml b/browser/modules/test/unit/xpcshell.toml
new file mode 100644
index 0000000000..1738e92194
--- /dev/null
+++ b/browser/modules/test/unit/xpcshell.toml
@@ -0,0 +1,32 @@
+[DEFAULT]
+head =  ''
+firefox-appdir = "browser"
+skip-if = ["os == 'android'"] # bug 1730213
+
+["test_E10SUtils_nested_URIs.js"]
+
+["test_HomePage.js"]
+
+["test_HomePage_ignore.js"]
+
+["test_InstallationTelemetry.js"]
+run-if = ["os == 'win'"] # Test of a Windows-specific feature
+
+["test_LaterRun.js"]
+
+["test_ProfileCounter.js"]
+run-if = ["os == 'win'"] # Test of a Windows-specific feature
+
+["test_Sanitizer_interrupted.js"]
+
+["test_SiteDataManager.js"]
+
+["test_SiteDataManagerContainers.js"]
+
+["test_SitePermissions.js"]
+
+["test_SitePermissions_temporary.js"]
+
+["test_TabUnloader.js"]
+
+["test_discovery.js"]
diff --git a/browser/modules/webrtcUI.sys.mjs b/browser/modules/webrtcUI.sys.mjs
new file mode 100644
index 0000000000..384cec16af
--- /dev/null
+++ b/browser/modules/webrtcUI.sys.mjs
@@ -0,0 +1,1152 @@
+/* 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/. */
+
+import { EventEmitter } from "resource:///modules/syncedtabs/EventEmitter.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
+  SitePermissions: "resource:///modules/SitePermissions.sys.mjs",
+});
+ChromeUtils.defineLazyGetter(
+  lazy,
+  "syncL10n",
+  () => new Localization(["browser/webrtcIndicator.ftl"], true)
+);
+ChromeUtils.defineLazyGetter(
+  lazy,
+  "listFormat",
+  () => new Services.intl.ListFormat(undefined)
+);
+
+const SHARING_L10NID_BY_TYPE = new Map([
+  [
+    "Camera",
+    [
+      "webrtc-indicator-menuitem-sharing-camera-with",
+      "webrtc-indicator-menuitem-sharing-camera-with-n-tabs",
+    ],
+  ],
+  [
+    "Microphone",
+    [
+      "webrtc-indicator-menuitem-sharing-microphone-with",
+      "webrtc-indicator-menuitem-sharing-microphone-with-n-tabs",
+    ],
+  ],
+  [
+    "Application",
+    [
+      "webrtc-indicator-menuitem-sharing-application-with",
+      "webrtc-indicator-menuitem-sharing-application-with-n-tabs",
+    ],
+  ],
+  [
+    "Screen",
+    [
+      "webrtc-indicator-menuitem-sharing-screen-with",
+      "webrtc-indicator-menuitem-sharing-screen-with-n-tabs",
+    ],
+  ],
+  [
+    "Window",
+    [
+      "webrtc-indicator-menuitem-sharing-window-with",
+      "webrtc-indicator-menuitem-sharing-window-with-n-tabs",
+    ],
+  ],
+  [
+    "Browser",
+    [
+      "webrtc-indicator-menuitem-sharing-browser-with",
+      "webrtc-indicator-menuitem-sharing-browser-with-n-tabs",
+    ],
+  ],
+]);
+
+// These identifiers are defined in MediaStreamTrack.webidl
+const MEDIA_SOURCE_L10NID_BY_TYPE = new Map([
+  ["camera", "webrtc-item-camera"],
+  ["screen", "webrtc-item-screen"],
+  ["application", "webrtc-item-application"],
+  ["window", "webrtc-item-window"],
+  ["browser", "webrtc-item-browser"],
+  ["microphone", "webrtc-item-microphone"],
+  ["audioCapture", "webrtc-item-audio-capture"],
+]);
+
+export var webrtcUI = {
+  initialized: false,
+
+  peerConnectionBlockers: new Set(),
+  emitter: new EventEmitter(),
+
+  init() {
+    if (!this.initialized) {
+      Services.obs.addObserver(this, "browser-delayed-startup-finished");
+      this.initialized = true;
+
+      XPCOMUtils.defineLazyPreferenceGetter(
+        this,
+        "deviceGracePeriodTimeoutMs",
+        "privacy.webrtc.deviceGracePeriodTimeoutMs"
+      );
+      XPCOMUtils.defineLazyPreferenceGetter(
+        this,
+        "showIndicatorsOnMacos14AndAbove",
+        "privacy.webrtc.showIndicatorsOnMacos14AndAbove",
+        true
+      );
+
+      Services.telemetry.setEventRecordingEnabled("webrtc.ui", true);
+    }
+  },
+
+  uninit() {
+    if (this.initialized) {
+      Services.obs.removeObserver(this, "browser-delayed-startup-finished");
+      this.initialized = false;
+    }
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "browser-delayed-startup-finished") {
+      if (webrtcUI.showGlobalIndicator) {
+        showOrCreateMenuForWindow(subject);
+      }
+    }
+  },
+
+  SHARING_NONE: 0,
+  SHARING_WINDOW: 1,
+  SHARING_SCREEN: 2,
+
+  // Set of browser windows that are being shared over WebRTC.
+  sharedBrowserWindows: new WeakSet(),
+
+  // True if one or more screens is being shared.
+  sharingScreen: false,
+
+  allowedSharedBrowsers: new WeakSet(),
+  allowTabSwitchesForSession: false,
+  tabSwitchCountForSession: 0,
+
+  // True if a window or screen is being shared.
+  sharingDisplay: false,
+
+  // The session ID is used to try to differentiate between instances
+  // where the user is sharing their display somehow. If the user
+  // transitions from a state of not sharing their display, to sharing a
+  // display, we bump the ID.
+  sharingDisplaySessionId: 0,
+
+  // Map of browser elements to indicator data.
+  perTabIndicators: new Map(),
+  activePerms: new Map(),
+
+  get showGlobalIndicator() {
+    for (let [, indicators] of this.perTabIndicators) {
+      if (
+        indicators.showCameraIndicator ||
+        indicators.showMicrophoneIndicator ||
+        indicators.showScreenSharingIndicator
+      ) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  get showCameraIndicator() {
+    // Bug 1857254 - MacOS 14 displays two camera icons in menu bar
+    // temporarily disabled the firefox camera icon until a better fix comes around
+    if (
+      AppConstants.isPlatformAndVersionAtLeast("macosx", 14.0) &&
+      !this.showIndicatorsOnMacos14AndAbove
+    ) {
+      return false;
+    }
+
+    for (let [, indicators] of this.perTabIndicators) {
+      if (indicators.showCameraIndicator) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  get showMicrophoneIndicator() {
+    // Bug 1857254 - MacOS 14 displays two microphone icons in menu bar
+    // temporarily disabled the firefox camera icon until a better fix comes around
+    if (
+      AppConstants.isPlatformAndVersionAtLeast("macosx", 14.0) &&
+      !this.showIndicatorsOnMacos14AndAbove
+    ) {
+      return false;
+    }
+
+    for (let [, indicators] of this.perTabIndicators) {
+      if (indicators.showMicrophoneIndicator) {
+        return true;
+      }
+    }
+    return false;
+  },
+
+  get showScreenSharingIndicator() {
+    // Bug 1857254 - MacOS 14 displays two screen share icons in menu bar
+    // temporarily disabled the firefox camera icon until a better fix comes around
+    if (
+      AppConstants.isPlatformAndVersionAtLeast("macosx", 14.0) &&
+      !this.showIndicatorsOnMacos14AndAbove
+    ) {
+      return "";
+    }
+
+    let list = [""];
+    for (let [, indicators] of this.perTabIndicators) {
+      if (indicators.showScreenSharingIndicator) {
+        list.push(indicators.showScreenSharingIndicator);
+      }
+    }
+
+    let precedence = ["Screen", "Window", "Application", "Browser", ""];
+
+    list.sort((a, b) => {
+      return precedence.indexOf(a) - precedence.indexOf(b);
+    });
+
+    return list[0];
+  },
+
+  _streams: [],
+  // The boolean parameters indicate which streams should be included in the result.
+  getActiveStreams(aCamera, aMicrophone, aScreen, aWindow = false) {
+    return webrtcUI._streams
+      .filter(aStream => {
+        let state = aStream.state;
+        return (
+          (aCamera && state.camera) ||
+          (aMicrophone && state.microphone) ||
+          (aScreen && state.screen) ||
+          (aWindow && state.window)
+        );
+      })
+      .map(aStream => {
+        let state = aStream.state;
+        let types = {
+          camera: state.camera,
+          microphone: state.microphone,
+          screen: state.screen,
+          window: state.window,
+        };
+        let browser = aStream.topBrowsingContext.embedderElement;
+        // browser can be null when we are in the process of closing a tab
+        // and our stream list hasn't been updated yet.
+        // gBrowser will be null if a stream is used outside a tabbrowser window.
+        let tab = browser?.ownerGlobal.gBrowser?.getTabForBrowser(browser);
+        return {
+          uri: state.documentURI,
+          tab,
+          browser,
+          types,
+          devices: state.devices,
+        };
+      });
+  },
+
+  /**
+   * Returns true if aBrowser has an active WebRTC stream.
+   */
+  browserHasStreams(aBrowser) {
+    for (let stream of this._streams) {
+      if (stream.topBrowsingContext.embedderElement == aBrowser) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+
+  /**
+   * Determine the combined state of all the active streams associated with
+   * the specified top-level browsing context.
+   */
+  getCombinedStateForBrowser(aTopBrowsingContext) {
+    function combine(x, y) {
+      if (
+        x == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED ||
+        y == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED
+      ) {
+        return Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED;
+      }
+      if (
+        x == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED ||
+        y == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED
+      ) {
+        return Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED;
+      }
+      return Ci.nsIMediaManagerService.STATE_NOCAPTURE;
+    }
+
+    let camera, microphone, screen, window, browser;
+    for (let stream of this._streams) {
+      if (stream.topBrowsingContext == aTopBrowsingContext) {
+        camera = combine(stream.state.camera, camera);
+        microphone = combine(stream.state.microphone, microphone);
+        screen = combine(stream.state.screen, screen);
+        window = combine(stream.state.window, window);
+        browser = combine(stream.state.browser, browser);
+      }
+    }
+
+    let tabState = { camera, microphone };
+    if (screen == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED) {
+      tabState.screen = "Screen";
+    } else if (window == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED) {
+      tabState.screen = "Window";
+    } else if (browser == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED) {
+      tabState.screen = "Browser";
+    } else if (screen == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED) {
+      tabState.screen = "ScreenPaused";
+    } else if (window == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED) {
+      tabState.screen = "WindowPaused";
+    } else if (browser == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED) {
+      tabState.screen = "BrowserPaused";
+    }
+
+    let screenEnabled = tabState.screen && !tabState.screen.includes("Paused");
+    let cameraEnabled =
+      tabState.camera == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED;
+    let microphoneEnabled =
+      tabState.microphone == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED;
+
+    // tabState.sharing controls which global indicator should be shown
+    // for the tab. It should always be set to the _enabled_ device which
+    // we consider most intrusive (screen > camera > microphone).
+    if (screenEnabled) {
+      tabState.sharing = "screen";
+    } else if (cameraEnabled) {
+      tabState.sharing = "camera";
+    } else if (microphoneEnabled) {
+      tabState.sharing = "microphone";
+    } else if (tabState.screen) {
+      tabState.sharing = "screen";
+    } else if (tabState.camera) {
+      tabState.sharing = "camera";
+    } else if (tabState.microphone) {
+      tabState.sharing = "microphone";
+    }
+
+    // The stream is considered paused when we're sharing something
+    // but all devices are off or set to disabled.
+    tabState.paused =
+      tabState.sharing &&
+      !screenEnabled &&
+      !cameraEnabled &&
+      !microphoneEnabled;
+
+    if (
+      tabState.camera == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED ||
+      tabState.camera == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED
+    ) {
+      tabState.showCameraIndicator = true;
+    }
+    if (
+      tabState.microphone == Ci.nsIMediaManagerService.STATE_CAPTURE_ENABLED ||
+      tabState.microphone == Ci.nsIMediaManagerService.STATE_CAPTURE_DISABLED
+    ) {
+      tabState.showMicrophoneIndicator = true;
+    }
+
+    tabState.showScreenSharingIndicator = "";
+    if (tabState.screen) {
+      if (tabState.screen.startsWith("Screen")) {
+        tabState.showScreenSharingIndicator = "Screen";
+      } else if (tabState.screen.startsWith("Window")) {
+        if (tabState.showScreenSharingIndicator != "Screen") {
+          tabState.showScreenSharingIndicator = "Window";
+        }
+      } else if (tabState.screen.startsWith("Browser")) {
+        if (!tabState.showScreenSharingIndicator) {
+          tabState.showScreenSharingIndicator = "Browser";
+        }
+      }
+    }
+
+    return tabState;
+  },
+
+  /*
+   * Indicate that a stream has been added or removed from the given
+   * browsing context. If it has been added, aData specifies the
+   * specific indicator types it uses. If aData is null or has no
+   * documentURI assigned, then the stream has been removed.
+   */
+  streamAddedOrRemoved(aBrowsingContext, aData) {
+    this.init();
+
+    let index;
+    for (index = 0; index < webrtcUI._streams.length; ++index) {
+      let stream = this._streams[index];
+      if (stream.browsingContext == aBrowsingContext) {
+        break;
+      }
+    }
+    // The update is a removal of the stream, triggered by the
+    // recording-window-ended notification.
+    if (aData.remove) {
+      if (index < this._streams.length) {
+        this._streams.splice(index, 1);
+      }
+    } else {
+      this._streams[index] = {
+        browsingContext: aBrowsingContext,
+        topBrowsingContext: aBrowsingContext.top,
+        state: aData,
+      };
+    }
+
+    let wasSharingDisplay = this.sharingDisplay;
+
+    // Reset our internal notion of whether or not we're sharing
+    // a screen or browser window. Now we'll go through the shared
+    // devices and re-determine what's being shared.
+    let sharingBrowserWindow = false;
+    let sharedWindowRawDeviceIds = new Set();
+    this.sharingDisplay = false;
+    this.sharingScreen = false;
+    let suppressNotifications = false;
+
+    // First, go through the streams and collect the counts on things
+    // like the total number of shared windows, and whether or not we're
+    // sharing screens.
+    for (let stream of this._streams) {
+      let { state } = stream;
+      suppressNotifications |= state.suppressNotifications;
+
+      for (let device of state.devices) {
+        let mediaSource = device.mediaSource;
+
+        if (mediaSource == "window" || mediaSource == "screen") {
+          this.sharingDisplay = true;
+        }
+
+        if (!device.scary) {
+          continue;
+        }
+
+        if (mediaSource == "window") {
+          sharedWindowRawDeviceIds.add(device.rawId);
+        } else if (mediaSource == "screen") {
+          this.sharingScreen = true;
+        }
+
+        // If the user has granted a particular site the ability
+        // to get a stream from a window or screen, we will
+        // presume that it's exempt from the tab switch warning.
+        //
+        // We use the permanentKey here so that the allowing of
+        // the tab survives tab tear-in and tear-out. We ignore
+        // browsers that don't have permanentKey, since those aren't
+        // tabbrowser browsers.
+        let browser = stream.topBrowsingContext.embedderElement;
+        if (browser.permanentKey) {
+          this.allowedSharedBrowsers.add(browser.permanentKey);
+        }
+      }
+    }
+
+    // Next, go through the list of shared windows, and map them
+    // to our browser windows so that we know which ones are shared.
+    this.sharedBrowserWindows = new WeakSet();
+
+    for (let win of lazy.BrowserWindowTracker.orderedWindows) {
+      let rawDeviceId;
+      try {
+        rawDeviceId = win.windowUtils.webrtcRawDeviceId;
+      } catch (e) {
+        // This can theoretically throw if some of the underlying
+        // window primitives don't exist. In that case, we can skip
+        // to the next window.
+        continue;
+      }
+      if (sharedWindowRawDeviceIds.has(rawDeviceId)) {
+        this.sharedBrowserWindows.add(win);
+
+        // If we've shared a window, then the initially selected tab
+        // in that window should be exempt from tab switch warnings,
+        // since it's already been shared.
+        let selectedBrowser = win.gBrowser.selectedBrowser;
+        this.allowedSharedBrowsers.add(selectedBrowser.permanentKey);
+
+        sharingBrowserWindow = true;
+      }
+    }
+
+    // If we weren't sharing a window or screen, and now are, bump
+    // the sharingDisplaySessionId. We use this ID for Event
+    // telemetry, and consider a transition from no shared displays
+    // to some shared displays as a new session.
+    if (!wasSharingDisplay && this.sharingDisplay) {
+      this.sharingDisplaySessionId++;
+    }
+
+    // If we were adding a new display stream, record some Telemetry for
+    // it with the most recent sharedDisplaySessionId. We do this separately
+    // from the loops above because those take into account the pre-existing
+    // streams that might already have been shared.
+    if (aData.devices) {
+      // The mixture of camelCase with under_score notation here is due to
+      // an unfortunate collision of conventions between this file and
+      // Event Telemetry.
+      let silence_notifs = suppressNotifications ? "true" : "false";
+      for (let device of aData.devices) {
+        if (device.mediaSource == "screen") {
+          this.recordEvent("share_display", "screen", {
+            silence_notifs,
+          });
+        } else if (device.mediaSource == "window") {
+          if (device.scary) {
+            this.recordEvent("share_display", "browser_window", {
+              silence_notifs,
+            });
+          } else {
+            this.recordEvent("share_display", "window", {
+              silence_notifs,
+            });
+          }
+        }
+      }
+    }
+
+    // Since we're not sharing a screen or browser window,
+    // we can clear these state variables, which are used
+    // to warn users on tab switching when sharing. These
+    // are safe to reset even if we hadn't been sharing
+    // the screen or browser window already.
+    if (!this.sharingScreen && !sharingBrowserWindow) {
+      this.allowedSharedBrowsers = new WeakSet();
+      this.allowTabSwitchesForSession = false;
+      this.tabSwitchCountForSession = 0;
+    }
+
+    this._setSharedData();
+    if (
+      Services.prefs.getBoolPref(
+        "privacy.webrtc.allowSilencingNotifications",
+        false
+      )
+    ) {
+      let alertsService = Cc["@mozilla.org/alerts-service;1"]
+        .getService(Ci.nsIAlertsService)
+        .QueryInterface(Ci.nsIAlertsDoNotDisturb);
+      alertsService.suppressForScreenSharing = suppressNotifications;
+    }
+  },
+
+  /**
+   * Remove all the streams associated with a given
+   * browsing context.
+   */
+  forgetStreamsFromBrowserContext(aBrowsingContext) {
+    for (let index = 0; index < webrtcUI._streams.length; ) {
+      let stream = this._streams[index];
+      if (stream.browsingContext == aBrowsingContext) {
+        this._streams.splice(index, 1);
+      } else {
+        index++;
+      }
+    }
+
+    // Remove the per-tab indicator if it no longer needs to be displayed.
+    let topBC = aBrowsingContext.top;
+    if (this.perTabIndicators.has(topBC)) {
+      let tabState = this.getCombinedStateForBrowser(topBC);
+      if (
+        !tabState.showCameraIndicator &&
+        !tabState.showMicrophoneIndicator &&
+        !tabState.showScreenSharingIndicator
+      ) {
+        this.perTabIndicators.delete(topBC);
+      }
+    }
+
+    this.updateGlobalIndicator();
+    this._setSharedData();
+  },
+
+  /**
+   * Given some set of streams, stops device access for those streams.
+   * Optionally, it's possible to stop a subset of the devices on those
+   * streams by passing in optional arguments.
+   *
+   * Once the streams have been stopped, this method will also find the
+   * newest stream's <xul:browser> and window, focus the window, and
+   * select the browser.
+   *
+   * For camera and microphone streams, this will also revoke any associated
+   * permissions from SitePermissions.
+   *
+   * @param {Array<Object>} activeStreams - An array of streams obtained via webrtcUI.getActiveStreams.
+   * @param {boolean} stopCameras - True to stop the camera streams (defaults to true)
+   * @param {boolean} stopMics - True to stop the microphone streams (defaults to true)
+   * @param {boolean} stopScreens - True to stop the screen streams (defaults to true)
+   * @param {boolean} stopWindows - True to stop the window streams (defaults to true)
+   */
+  stopSharingStreams(
+    activeStreams,
+    stopCameras = true,
+    stopMics = true,
+    stopScreens = true,
+    stopWindows = true
+  ) {
+    if (!activeStreams.length) {
+      return;
+    }
+
+    let ids = [];
+    if (stopCameras) {
+      ids.push("camera");
+    }
+    if (stopMics) {
+      ids.push("microphone");
+    }
+    if (stopScreens || stopWindows) {
+      ids.push("screen");
+    }
+
+    for (let stream of activeStreams) {
+      let { browser } = stream;
+
+      let gBrowser = browser.getTabBrowser();
+      if (!gBrowser) {
+        console.error("Can't stop sharing stream - cannot find gBrowser.");
+        continue;
+      }
+
+      let tab = gBrowser.getTabForBrowser(browser);
+      if (!tab) {
+        console.error("Can't stop sharing stream - cannot find tab.");
+        continue;
+      }
+
+      this.clearPermissionsAndStopSharing(ids, tab);
+    }
+
+    // Switch to the newest stream's browser.
+    let mostRecentStream = activeStreams[activeStreams.length - 1];
+    let { browser: browserToSelect } = mostRecentStream;
+
+    let window = browserToSelect.ownerGlobal;
+    let gBrowser = browserToSelect.getTabBrowser();
+    let tab = gBrowser.getTabForBrowser(browserToSelect);
+    window.focus();
+    gBrowser.selectedTab = tab;
+  },
+
+  /**
+   * Clears permissions and stops sharing (if active) for a list of device types
+   * and a specific tab.
+   * @param {("camera"|"microphone"|"screen")[]} types - Device types to stop
+   * and clear permissions for.
+   * @param tab - Tab of the devices to stop and clear permissions.
+   */
+  clearPermissionsAndStopSharing(types, tab) {
+    let invalidTypes = types.filter(
+      type => !["camera", "screen", "microphone", "speaker"].includes(type)
+    );
+    if (invalidTypes.length) {
+      throw new Error(`Invalid device types ${invalidTypes.join(",")}`);
+    }
+    let browser = tab.linkedBrowser;
+    let sharingState = tab._sharingState?.webRTC;
+
+    // If we clear a WebRTC permission we need to remove all permissions of
+    // the same type across device ids. We also need to stop active WebRTC
+    // devices related to the permission.
+    let perms = lazy.SitePermissions.getAllForBrowser(browser);
+
+    // If capturing, don't revoke one of camera/microphone without the other.
+    let sharingCameraOrMic =
+      (sharingState?.camera || sharingState?.microphone) &&
+      (types.includes("camera") || types.includes("microphone"));
+
+    perms
+      .filter(perm => {
+        let [id] = perm.id.split(lazy.SitePermissions.PERM_KEY_DELIMITER);
+        if (sharingCameraOrMic && (id == "camera" || id == "microphone")) {
+          return true;
+        }
+        return types.includes(id);
+      })
+      .forEach(perm => {
+        lazy.SitePermissions.removeFromPrincipal(
+          browser.contentPrincipal,
+          perm.id,
+          browser
+        );
+      });
+
+    if (!sharingState?.windowId) {
+      return;
+    }
+
+    // If the device of the permission we're clearing is currently active,
+    // tell the WebRTC implementation to stop sharing it.
+    let { windowId } = sharingState;
+
+    let windowIds = [];
+    if (types.includes("screen") && sharingState.screen) {
+      windowIds.push(`screen:${windowId}`);
+    }
+    if (sharingCameraOrMic) {
+      windowIds.push(windowId);
+    }
+
+    if (!windowIds.length) {
+      return;
+    }
+
+    let actor =
+      sharingState.browsingContext.currentWindowGlobal.getActor("WebRTC");
+
+    // Delete activePerms for all outerWindowIds under the current browser. We
+    // need to do this prior to sending the stopSharing message, so WebRTCParent
+    // can skip adding grace periods for these devices.
+    webrtcUI.forgetActivePermissionsFromBrowser(browser);
+
+    windowIds.forEach(id => actor.sendAsyncMessage("webrtc:StopSharing", id));
+  },
+
+  updateIndicators(aTopBrowsingContext) {
+    let tabState = this.getCombinedStateForBrowser(aTopBrowsingContext);
+
+    let indicators;
+    if (this.perTabIndicators.has(aTopBrowsingContext)) {
+      indicators = this.perTabIndicators.get(aTopBrowsingContext);
+    } else {
+      indicators = {};
+      this.perTabIndicators.set(aTopBrowsingContext, indicators);
+    }
+
+    indicators.showCameraIndicator = tabState.showCameraIndicator;
+    indicators.showMicrophoneIndicator = tabState.showMicrophoneIndicator;
+    indicators.showScreenSharingIndicator = tabState.showScreenSharingIndicator;
+    this.updateGlobalIndicator();
+
+    return tabState;
+  },
+
+  swapBrowserForNotification(aOldBrowser, aNewBrowser) {
+    for (let stream of this._streams) {
+      if (stream.browser == aOldBrowser) {
+        stream.browser = aNewBrowser;
+      }
+    }
+  },
+
+  /**
+   * Remove all entries from the activePerms map for a browser, including all
+   * child frames.
+   * Note: activePerms is an internal WebRTC UI permission map and does not
+   * reflect the PermissionManager or SitePermissions state.
+   * @param aBrowser - Browser to clear active permissions for.
+   */
+  forgetActivePermissionsFromBrowser(aBrowser) {
+    let browserWindowIds = aBrowser.browsingContext
+      .getAllBrowsingContextsInSubtree()
+      .map(bc => bc.currentWindowGlobal?.outerWindowId)
+      .filter(id => id != null);
+    browserWindowIds.push(aBrowser.outerWindowId);
+    browserWindowIds.forEach(id => this.activePerms.delete(id));
+  },
+
+  /**
+   * Shows the Permission Panel for the tab associated with the provided
+   * active stream.
+   * @param aActiveStream - The stream that the user wants to see permissions for.
+   * @param aEvent - The user input event that is invoking the panel. This can be
+   *        undefined / null if no such event exists.
+   */
+  showSharingDoorhanger(aActiveStream, aEvent) {
+    let browserWindow = aActiveStream.browser.ownerGlobal;
+    if (aActiveStream.tab) {
+      browserWindow.gBrowser.selectedTab = aActiveStream.tab;
+    } else {
+      aActiveStream.browser.focus();
+    }
+    browserWindow.focus();
+
+    if (AppConstants.platform == "macosx" && !Services.focus.activeWindow) {
+      browserWindow.addEventListener(
+        "activate",
+        function () {
+          Services.tm.dispatchToMainThread(function () {
+            browserWindow.gPermissionPanel.openPopup(aEvent);
+          });
+        },
+        { once: true }
+      );
+      Cc["@mozilla.org/widget/macdocksupport;1"]
+        .getService(Ci.nsIMacDockSupport)
+        .activateApplication(true);
+      return;
+    }
+    browserWindow.gPermissionPanel.openPopup(aEvent);
+  },
+
+  updateWarningLabel(aMenuList) {
+    let type = aMenuList.selectedItem.getAttribute("devicetype");
+    let document = aMenuList.ownerDocument;
+    document.getElementById("webRTC-all-windows-shared").hidden =
+      type != "screen";
+  },
+
+  // Add-ons can override stock permission behavior by doing:
+  //
+  //   webrtcUI.addPeerConnectionBlocker(function(aParams) {
+  //     // new permission checking logic
+  //   }));
+  //
+  // The blocking function receives an object with origin, callID, and windowID
+  // parameters.  If it returns the string "deny" or a Promise that resolves
+  // to "deny", the connection is immediately blocked.  With any other return
+  // value (though the string "allow" is suggested for consistency), control
+  // is passed to other registered blockers.  If no registered blockers block
+  // the connection (or of course if there are no registered blockers), then
+  // the connection is allowed.
+  //
+  // Add-ons may also use webrtcUI.on/off to listen to events without
+  // blocking anything:
+  //   peer-request-allowed is emitted when a new peer connection is
+  //                        established (and not blocked).
+  //   peer-request-blocked is emitted when a peer connection request is
+  //                        blocked by some blocking connection handler.
+  //   peer-request-cancel is emitted when a peer-request connection request
+  //                       is canceled.  (This would typically be used in
+  //                       conjunction with a blocking handler to cancel
+  //                       a user prompt or other work done by the handler)
+  addPeerConnectionBlocker(aCallback) {
+    this.peerConnectionBlockers.add(aCallback);
+  },
+
+  removePeerConnectionBlocker(aCallback) {
+    this.peerConnectionBlockers.delete(aCallback);
+  },
+
+  on(...args) {
+    return this.emitter.on(...args);
+  },
+
+  off(...args) {
+    return this.emitter.off(...args);
+  },
+
+  getHostOrExtensionName(uri, href) {
+    let host;
+    try {
+      if (!uri) {
+        uri = Services.io.newURI(href);
+      }
+
+      let addonPolicy = WebExtensionPolicy.getByURI(uri);
+      host = addonPolicy?.name ?? uri.hostPort;
+    } catch (ex) {}
+
+    if (!host) {
+      if (uri && uri.scheme.toLowerCase() == "about") {
+        // For about URIs, just use the full spec, without any #hash parts.
+        host = uri.specIgnoringRef;
+      } else {
+        // This is unfortunate, but we should display *something*...
+        host = lazy.syncL10n.formatValueSync(
+          "webrtc-sharing-menuitem-unknown-host"
+        );
+      }
+    }
+    return host;
+  },
+
+  updateGlobalIndicator() {
+    for (let chromeWin of Services.wm.getEnumerator("navigator:browser")) {
+      if (this.showGlobalIndicator) {
+        showOrCreateMenuForWindow(chromeWin);
+      } else {
+        let doc = chromeWin.document;
+        let existingMenu = doc.getElementById("tabSharingMenu");
+        if (existingMenu) {
+          existingMenu.hidden = true;
+        }
+        if (AppConstants.platform == "macosx") {
+          let separator = doc.getElementById("tabSharingSeparator");
+          if (separator) {
+            separator.hidden = true;
+          }
+        }
+      }
+    }
+
+    if (this.showGlobalIndicator) {
+      if (!gIndicatorWindow) {
+        gIndicatorWindow = getGlobalIndicator();
+      } else {
+        try {
+          gIndicatorWindow.updateIndicatorState();
+        } catch (err) {
+          console.error(
+            `error in gIndicatorWindow.updateIndicatorState(): ${err.message}`
+          );
+        }
+      }
+    } else if (gIndicatorWindow) {
+      if (gIndicatorWindow.closingInternally) {
+        // Before calling .close(), we call .closingInternally() to allow us to
+        // differentiate between situations where the indicator closes because
+        // we no longer want to show the indicator (this case), and cases where
+        // the user has found a way to close the indicator via OS window control
+        // mechanisms.
+        gIndicatorWindow.closingInternally();
+      }
+      gIndicatorWindow.close();
+      gIndicatorWindow = null;
+    }
+  },
+
+  getWindowShareState(window) {
+    if (this.sharingScreen) {
+      return this.SHARING_SCREEN;
+    } else if (this.sharedBrowserWindows.has(window)) {
+      return this.SHARING_WINDOW;
+    }
+    return this.SHARING_NONE;
+  },
+
+  tabAddedWhileSharing(tab) {
+    this.allowedSharedBrowsers.add(tab.linkedBrowser.permanentKey);
+  },
+
+  shouldShowSharedTabWarning(tab) {
+    if (!tab || !tab.linkedBrowser) {
+      return false;
+    }
+
+    let browser = tab.linkedBrowser;
+    // We want the user to be able to switch to one tab after starting
+    // to share their window or screen. The presumption here is that
+    // most users will have a single window with multiple tabs, where
+    // the selected tab will be the one with the screen or window
+    // sharing web application, and it's most likely that the contents
+    // that the user wants to share are in another tab that they'll
+    // switch to immediately upon sharing. These presumptions are based
+    // on research that our user research team did with users using
+    // video conferencing web applications.
+    if (!this.tabSwitchCountForSession) {
+      this.allowedSharedBrowsers.add(browser.permanentKey);
+    }
+
+    this.tabSwitchCountForSession++;
+    let shouldShow =
+      !this.allowTabSwitchesForSession &&
+      !this.allowedSharedBrowsers.has(browser.permanentKey);
+
+    return shouldShow;
+  },
+
+  allowSharedTabSwitch(tab, allowForSession) {
+    let browser = tab.linkedBrowser;
+    let gBrowser = browser.getTabBrowser();
+    this.allowedSharedBrowsers.add(browser.permanentKey);
+    gBrowser.selectedTab = tab;
+    this.allowTabSwitchesForSession = allowForSession;
+  },
+
+  recordEvent(type, object, args = {}) {
+    Services.telemetry.recordEvent(
+      "webrtc.ui",
+      type,
+      object,
+      this.sharingDisplaySessionId.toString(),
+      args
+    );
+  },
+
+  /**
+   * Updates the sharedData structure to reflect shared screen and window
+   * state. This sets the following key: data pairs on sharedData.
+   * - "webrtcUI:isSharingScreen": a boolean value reflecting
+   * this.sharingScreen.
+   * - "webrtcUI:sharedTopInnerWindowIds": a set containing the inner window
+   * ids of each top level browser window that is in sharedBrowserWindows.
+   */
+  _setSharedData() {
+    let sharedTopInnerWindowIds = new Set();
+    for (let win of lazy.BrowserWindowTracker.orderedWindows) {
+      if (this.sharedBrowserWindows.has(win)) {
+        sharedTopInnerWindowIds.add(
+          win.browsingContext.currentWindowGlobal.innerWindowId
+        );
+      }
+    }
+    Services.ppmm.sharedData.set(
+      "webrtcUI:isSharingScreen",
+      this.sharingScreen
+    );
+    Services.ppmm.sharedData.set(
+      "webrtcUI:sharedTopInnerWindowIds",
+      sharedTopInnerWindowIds
+    );
+  },
+};
+
+function getGlobalIndicator() {
+  const INDICATOR_CHROME_URI = "chrome://browser/content/webrtcIndicator.xhtml";
+  let features = "chrome,titlebar=no,alwaysontop,minimizable,dialog";
+
+  return Services.ww.openWindow(
+    null,
+    INDICATOR_CHROME_URI,
+    "_blank",
+    features,
+    null
+  );
+}
+
+/**
+ * Add a localized stream sharing menu to the event target
+ *
+ * @param {Window} win - The parent `window`
+ * @param {Event} event - The popupshowing event for the <menu>.
+ * @param {boolean} inclWindow - Should the window stream be included in the active streams.
+ */
+export function showStreamSharingMenu(win, event, inclWindow = false) {
+  win.MozXULElement.insertFTLIfNeeded("browser/webrtcIndicator.ftl");
+  const doc = win.document;
+  const menu = event.target;
+
+  let type = menu.getAttribute("type");
+  let activeStreams;
+  if (type == "Camera") {
+    activeStreams = webrtcUI.getActiveStreams(true, false, false);
+  } else if (type == "Microphone") {
+    activeStreams = webrtcUI.getActiveStreams(false, true, false);
+  } else if (type == "Screen") {
+    activeStreams = webrtcUI.getActiveStreams(false, false, true, inclWindow);
+    type = webrtcUI.showScreenSharingIndicator;
+  }
+
+  if (!activeStreams.length) {
+    event.preventDefault();
+    return;
+  }
+
+  const l10nIds = SHARING_L10NID_BY_TYPE.get(type) ?? [];
+  if (activeStreams.length == 1) {
+    let stream = activeStreams[0];
+
+    const sharingItem = doc.createXULElement("menuitem");
+    const streamTitle = stream.browser.contentTitle || stream.uri;
+    doc.l10n.setAttributes(sharingItem, l10nIds[0], { streamTitle });
+    sharingItem.setAttribute("disabled", "true");
+    menu.appendChild(sharingItem);
+
+    const controlItem = doc.createXULElement("menuitem");
+    doc.l10n.setAttributes(
+      controlItem,
+      "webrtc-indicator-menuitem-control-sharing"
+    );
+    controlItem.stream = stream;
+    controlItem.addEventListener("command", this);
+
+    menu.appendChild(controlItem);
+  } else {
+    // We show a different menu when there are several active streams.
+    const sharingItem = doc.createXULElement("menuitem");
+    doc.l10n.setAttributes(sharingItem, l10nIds[1], {
+      tabCount: activeStreams.length,
+    });
+    sharingItem.setAttribute("disabled", "true");
+    menu.appendChild(sharingItem);
+
+    for (let stream of activeStreams) {
+      const controlItem = doc.createXULElement("menuitem");
+      const streamTitle = stream.browser.contentTitle || stream.uri;
+      doc.l10n.setAttributes(
+        controlItem,
+        "webrtc-indicator-menuitem-control-sharing-on",
+        { streamTitle }
+      );
+      controlItem.stream = stream;
+      controlItem.addEventListener("command", this);
+      menu.appendChild(controlItem);
+    }
+  }
+}
+
+function onTabSharingMenuPopupShowing(e) {
+  const streams = webrtcUI.getActiveStreams(true, true, true, true);
+  for (let streamInfo of streams) {
+    const names = streamInfo.devices.map(({ mediaSource }) => {
+      const l10nId = MEDIA_SOURCE_L10NID_BY_TYPE.get(mediaSource);
+      return l10nId ? lazy.syncL10n.formatValueSync(l10nId) : mediaSource;
+    });
+
+    const doc = e.target.ownerDocument;
+    const menuitem = doc.createXULElement("menuitem");
+    doc.l10n.setAttributes(menuitem, "webrtc-sharing-menuitem", {
+      origin: webrtcUI.getHostOrExtensionName(null, streamInfo.uri),
+      itemList: lazy.listFormat.format(names),
+    });
+    menuitem.stream = streamInfo;
+    menuitem.addEventListener("command", onTabSharingMenuPopupCommand);
+    e.target.appendChild(menuitem);
+  }
+}
+
+function onTabSharingMenuPopupHiding(e) {
+  while (this.lastChild) {
+    this.lastChild.remove();
+  }
+}
+
+function onTabSharingMenuPopupCommand(e) {
+  webrtcUI.showSharingDoorhanger(e.target.stream, e);
+}
+
+function showOrCreateMenuForWindow(aWindow) {
+  let document = aWindow.document;
+  let menu = document.getElementById("tabSharingMenu");
+  if (!menu) {
+    menu = document.createXULElement("menu");
+    menu.id = "tabSharingMenu";
+    document.l10n.setAttributes(menu, "webrtc-sharing-menu");
+
+    let container, insertionPoint;
+    if (AppConstants.platform == "macosx") {
+      container = document.getElementById("menu_ToolsPopup");
+      insertionPoint = document.getElementById("devToolsSeparator");
+      let separator = document.createXULElement("menuseparator");
+      separator.id = "tabSharingSeparator";
+      container.insertBefore(separator, insertionPoint);
+    } else {
+      container = document.getElementById("main-menubar");
+      insertionPoint = document.getElementById("helpMenu");
+    }
+    let popup = document.createXULElement("menupopup");
+    popup.id = "tabSharingMenuPopup";
+    popup.addEventListener("popupshowing", onTabSharingMenuPopupShowing);
+    popup.addEventListener("popuphiding", onTabSharingMenuPopupHiding);
+    menu.appendChild(popup);
+    container.insertBefore(menu, insertionPoint);
+  } else {
+    menu.hidden = false;
+    if (AppConstants.platform == "macosx") {
+      document.getElementById("tabSharingSeparator").hidden = false;
+    }
+  }
+}
+
+var gIndicatorWindow = null;