Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 3385 insertions, 0 deletions

diff --git a/browser/components/preferences/privacy.js b/browser/components/preferences/privacy.js
new file mode 100644
index 0000000000..178bc560c7
--- /dev/null
+++ b/browser/components/preferences/privacy.js
@@ -0,0 +1,3385 @@
+/* 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-globals-from extensionControlled.js */
+/* import-globals-from preferences.js */
+
+const PREF_UPLOAD_ENABLED = "datareporting.healthreport.uploadEnabled";
+
+const TRACKING_PROTECTION_KEY = "websites.trackingProtectionMode";
+const TRACKING_PROTECTION_PREFS = [
+  "privacy.trackingprotection.enabled",
+  "privacy.trackingprotection.pbmode.enabled",
+];
+const CONTENT_BLOCKING_PREFS = [
+  "privacy.trackingprotection.enabled",
+  "privacy.trackingprotection.pbmode.enabled",
+  "network.cookie.cookieBehavior",
+  "privacy.trackingprotection.fingerprinting.enabled",
+  "privacy.trackingprotection.cryptomining.enabled",
+  "privacy.firstparty.isolate",
+  "privacy.trackingprotection.emailtracking.enabled",
+  "privacy.trackingprotection.emailtracking.pbmode.enabled",
+  "privacy.fingerprintingProtection",
+  "privacy.fingerprintingProtection.pbmode",
+];
+
+/*
+ * Prefs that are unique to sanitizeOnShutdown and are not shared
+ * with the deleteOnClose mechanism like privacy.clearOnShutdown.cookies, -cache and -offlineApps
+ */
+const SANITIZE_ON_SHUTDOWN_PREFS_ONLY = [
+  "privacy.clearOnShutdown.history",
+  "privacy.clearOnShutdown.downloads",
+  "privacy.clearOnShutdown.sessions",
+  "privacy.clearOnShutdown.formdata",
+  "privacy.clearOnShutdown.siteSettings",
+];
+
+const PREF_OPT_OUT_STUDIES_ENABLED = "app.shield.optoutstudies.enabled";
+const PREF_NORMANDY_ENABLED = "app.normandy.enabled";
+
+const PREF_ADDON_RECOMMENDATIONS_ENABLED = "browser.discovery.enabled";
+
+const PREF_PASSWORD_GENERATION_AVAILABLE = "signon.generation.available";
+const { BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN } = Ci.nsICookieService;
+
+const PASSWORD_MANAGER_PREF_ID = "services.passwordSavingEnabled";
+
+ChromeUtils.defineLazyGetter(this, "AlertsServiceDND", function () {
+  try {
+    let alertsService = Cc["@mozilla.org/alerts-service;1"]
+      .getService(Ci.nsIAlertsService)
+      .QueryInterface(Ci.nsIAlertsDoNotDisturb);
+    // This will throw if manualDoNotDisturb isn't implemented.
+    alertsService.manualDoNotDisturb;
+    return alertsService;
+  } catch (ex) {
+    return undefined;
+  }
+});
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "OS_AUTH_ENABLED",
+  "signon.management.page.os-auth.enabled",
+  true
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "gIsFirstPartyIsolated",
+  "privacy.firstparty.isolate",
+  false
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  this,
+  "useOldClearHistoryDialog",
+  "privacy.sanitize.useOldClearHistoryDialog",
+  false
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+  DoHConfigController: "resource:///modules/DoHConfig.sys.mjs",
+});
+
+Preferences.addAll([
+  // Content blocking / Tracking Protection
+  { id: "privacy.trackingprotection.enabled", type: "bool" },
+  { id: "privacy.trackingprotection.pbmode.enabled", type: "bool" },
+  { id: "privacy.trackingprotection.fingerprinting.enabled", type: "bool" },
+  { id: "privacy.trackingprotection.cryptomining.enabled", type: "bool" },
+  { id: "privacy.trackingprotection.emailtracking.enabled", type: "bool" },
+  {
+    id: "privacy.trackingprotection.emailtracking.pbmode.enabled",
+    type: "bool",
+  },
+
+  // Fingerprinting Protection
+  { id: "privacy.fingerprintingProtection", type: "bool" },
+  { id: "privacy.fingerprintingProtection.pbmode", type: "bool" },
+
+  // Resist Fingerprinting
+  { id: "privacy.resistFingerprinting", type: "bool" },
+  { id: "privacy.resistFingerprinting.pbmode", type: "bool" },
+
+  // Social tracking
+  { id: "privacy.trackingprotection.socialtracking.enabled", type: "bool" },
+  { id: "privacy.socialtracking.block_cookies.enabled", type: "bool" },
+
+  // Tracker list
+  { id: "urlclassifier.trackingTable", type: "string" },
+
+  // Button prefs
+  { id: "pref.privacy.disable_button.cookie_exceptions", type: "bool" },
+  {
+    id: "pref.privacy.disable_button.tracking_protection_exceptions",
+    type: "bool",
+  },
+
+  // Location Bar
+  { id: "browser.urlbar.suggest.bookmark", type: "bool" },
+  { id: "browser.urlbar.suggest.clipboard", type: "bool" },
+  { id: "browser.urlbar.suggest.history", type: "bool" },
+  { id: "browser.urlbar.suggest.openpage", type: "bool" },
+  { id: "browser.urlbar.suggest.topsites", type: "bool" },
+  { id: "browser.urlbar.suggest.engines", type: "bool" },
+  { id: "browser.urlbar.suggest.quicksuggest.nonsponsored", type: "bool" },
+  { id: "browser.urlbar.suggest.quicksuggest.sponsored", type: "bool" },
+  { id: "browser.urlbar.quicksuggest.dataCollection.enabled", type: "bool" },
+  { id: PREF_URLBAR_QUICKSUGGEST_BLOCKLIST, type: "string" },
+  { id: PREF_URLBAR_WEATHER_USER_ENABLED, type: "bool" },
+
+  // History
+  { id: "places.history.enabled", type: "bool" },
+  { id: "browser.formfill.enable", type: "bool" },
+  { id: "privacy.history.custom", type: "bool" },
+
+  // Cookies
+  { id: "network.cookie.cookieBehavior", type: "int" },
+  { id: "network.cookie.blockFutureCookies", type: "bool" },
+  // Content blocking category
+  { id: "browser.contentblocking.category", type: "string" },
+  { id: "browser.contentblocking.features.strict", type: "string" },
+
+  // Clear Private Data
+  { id: "privacy.sanitize.sanitizeOnShutdown", type: "bool" },
+  { id: "privacy.sanitize.timeSpan", type: "int" },
+  { id: "privacy.clearOnShutdown.cookies", type: "bool" },
+  { id: "privacy.clearOnShutdown.cache", type: "bool" },
+  { id: "privacy.clearOnShutdown.offlineApps", type: "bool" },
+  { id: "privacy.clearOnShutdown.history", type: "bool" },
+  { id: "privacy.clearOnShutdown.downloads", type: "bool" },
+  { id: "privacy.clearOnShutdown.sessions", type: "bool" },
+  { id: "privacy.clearOnShutdown.formdata", type: "bool" },
+  { id: "privacy.clearOnShutdown.siteSettings", type: "bool" },
+
+  // Do not track
+  { id: "privacy.donottrackheader.enabled", type: "bool" },
+
+  // Global Privacy Control
+  { id: "privacy.globalprivacycontrol.enabled", type: "bool" },
+
+  // Media
+  { id: "media.autoplay.default", type: "int" },
+
+  // Popups
+  { id: "dom.disable_open_during_load", type: "bool" },
+  // Passwords
+  { id: "signon.rememberSignons", type: "bool" },
+  { id: "signon.generation.enabled", type: "bool" },
+  { id: "signon.autofillForms", type: "bool" },
+  { id: "signon.management.page.breach-alerts.enabled", type: "bool" },
+  { id: "signon.firefoxRelay.feature", type: "string" },
+
+  // Buttons
+  { id: "pref.privacy.disable_button.view_passwords", type: "bool" },
+  { id: "pref.privacy.disable_button.view_passwords_exceptions", type: "bool" },
+
+  /* Certificates tab
+   * security.default_personal_cert
+   *   - a string:
+   *       "Select Automatically"   select a certificate automatically when a site
+   *                                requests one
+   *       "Ask Every Time"         present a dialog to the user so he can select
+   *                                the certificate to use on a site which
+   *                                requests one
+   */
+  { id: "security.default_personal_cert", type: "string" },
+
+  { id: "security.disable_button.openCertManager", type: "bool" },
+
+  { id: "security.disable_button.openDeviceManager", type: "bool" },
+
+  { id: "security.OCSP.enabled", type: "int" },
+
+  { id: "security.enterprise_roots.enabled", type: "bool" },
+
+  // Add-ons, malware, phishing
+  { id: "xpinstall.whitelist.required", type: "bool" },
+
+  { id: "browser.safebrowsing.malware.enabled", type: "bool" },
+  { id: "browser.safebrowsing.phishing.enabled", type: "bool" },
+
+  { id: "browser.safebrowsing.downloads.enabled", type: "bool" },
+
+  { id: "urlclassifier.malwareTable", type: "string" },
+
+  {
+    id: "browser.safebrowsing.downloads.remote.block_potentially_unwanted",
+    type: "bool",
+  },
+  { id: "browser.safebrowsing.downloads.remote.block_uncommon", type: "bool" },
+
+  // First-Party Isolation
+  { id: "privacy.firstparty.isolate", type: "bool" },
+
+  // HTTPS-Only
+  { id: "dom.security.https_only_mode", type: "bool" },
+  { id: "dom.security.https_only_mode_pbm", type: "bool" },
+  { id: "dom.security.https_first", type: "bool" },
+  { id: "dom.security.https_first_pbm", type: "bool" },
+
+  // Windows SSO
+  { id: "network.http.windows-sso.enabled", type: "bool" },
+
+  // Quick Actions
+  { id: "browser.urlbar.quickactions.showPrefs", type: "bool" },
+  { id: "browser.urlbar.suggest.quickactions", type: "bool" },
+
+  // Cookie Banner Handling
+  { id: "cookiebanners.ui.desktop.enabled", type: "bool" },
+  { id: "cookiebanners.service.mode.privateBrowsing", type: "int" },
+
+  // DoH
+  { id: "network.trr.mode", type: "int" },
+  { id: "network.trr.uri", type: "string" },
+  { id: "network.trr.default_provider_uri", type: "string" },
+  { id: "network.trr.custom_uri", type: "string" },
+  { id: "network.trr_ui.show_fallback_warning_option", type: "bool" },
+  { id: "network.trr.display_fallback_warning", type: "bool" },
+  { id: "doh-rollout.disable-heuristics", type: "bool" },
+]);
+
+// Study opt out
+if (AppConstants.MOZ_DATA_REPORTING) {
+  Preferences.addAll([
+    // Preference instances for prefs that we need to monitor while the page is open.
+    { id: PREF_OPT_OUT_STUDIES_ENABLED, type: "bool" },
+    { id: PREF_ADDON_RECOMMENDATIONS_ENABLED, type: "bool" },
+    { id: PREF_UPLOAD_ENABLED, type: "bool" },
+  ]);
+}
+// Privacy segmentation section
+Preferences.add({
+  id: "browser.dataFeatureRecommendations.enabled",
+  type: "bool",
+});
+
+// Data Choices tab
+if (AppConstants.MOZ_CRASHREPORTER) {
+  Preferences.add({
+    id: "browser.crashReports.unsubmittedCheck.autoSubmit2",
+    type: "bool",
+  });
+}
+
+function setEventListener(aId, aEventType, aCallback) {
+  document
+    .getElementById(aId)
+    .addEventListener(aEventType, aCallback.bind(gPrivacyPane));
+}
+
+function setSyncFromPrefListener(aId, aCallback) {
+  Preferences.addSyncFromPrefListener(document.getElementById(aId), aCallback);
+}
+
+function setSyncToPrefListener(aId, aCallback) {
+  Preferences.addSyncToPrefListener(document.getElementById(aId), aCallback);
+}
+
+function dataCollectionCheckboxHandler({
+  checkbox,
+  pref,
+  matchPref = () => true,
+  isDisabled = () => false,
+}) {
+  function updateCheckbox() {
+    let collectionEnabled = Services.prefs.getBoolPref(
+      PREF_UPLOAD_ENABLED,
+      false
+    );
+
+    if (collectionEnabled && matchPref()) {
+      if (Services.prefs.getBoolPref(pref, false)) {
+        checkbox.setAttribute("checked", "true");
+      } else {
+        checkbox.removeAttribute("checked");
+      }
+      checkbox.setAttribute("preference", pref);
+    } else {
+      checkbox.removeAttribute("preference");
+      checkbox.removeAttribute("checked");
+    }
+
+    checkbox.disabled =
+      !collectionEnabled || Services.prefs.prefIsLocked(pref) || isDisabled();
+  }
+
+  Preferences.get(PREF_UPLOAD_ENABLED).on("change", updateCheckbox);
+  updateCheckbox();
+}
+
+// Sets the "Learn how" SUMO link in the Strict/Custom options of Content Blocking.
+function setUpContentBlockingWarnings() {
+  document.getElementById("fpiIncompatibilityWarning").hidden =
+    !gIsFirstPartyIsolated;
+
+  document.getElementById("rfpIncompatibilityWarning").hidden =
+    !Preferences.get("privacy.resistFingerprinting").value &&
+    !Preferences.get("privacy.resistFingerprinting.pbmode").value;
+}
+
+function initTCPStandardSection() {
+  let cookieBehaviorPref = Preferences.get("network.cookie.cookieBehavior");
+  let updateTCPSectionVisibilityState = () => {
+    document.getElementById("etpStandardTCPBox").hidden =
+      cookieBehaviorPref.value !=
+      Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN;
+  };
+
+  cookieBehaviorPref.on("change", updateTCPSectionVisibilityState);
+
+  updateTCPSectionVisibilityState();
+}
+
+var gPrivacyPane = {
+  _pane: null,
+
+  /**
+   * Whether the prompt to restart Firefox should appear when changing the autostart pref.
+   */
+  _shouldPromptForRestart: true,
+
+  /**
+   * Update the tracking protection UI to deal with extension control.
+   */
+  _updateTrackingProtectionUI() {
+    let cBPrefisLocked = CONTENT_BLOCKING_PREFS.some(pref =>
+      Services.prefs.prefIsLocked(pref)
+    );
+    let tPPrefisLocked = TRACKING_PROTECTION_PREFS.some(pref =>
+      Services.prefs.prefIsLocked(pref)
+    );
+
+    function setInputsDisabledState(isControlled) {
+      let tpDisabled = tPPrefisLocked || isControlled;
+      let disabled = cBPrefisLocked || isControlled;
+      let tpCheckbox = document.getElementById(
+        "contentBlockingTrackingProtectionCheckbox"
+      );
+      // Only enable the TP menu if Detect All Trackers is enabled.
+      document.getElementById("trackingProtectionMenu").disabled =
+        tpDisabled || !tpCheckbox.checked;
+      tpCheckbox.disabled = tpDisabled;
+
+      document.getElementById("standardRadio").disabled = disabled;
+      document.getElementById("strictRadio").disabled = disabled;
+      document
+        .getElementById("contentBlockingOptionStrict")
+        .classList.toggle("disabled", disabled);
+      document
+        .getElementById("contentBlockingOptionStandard")
+        .classList.toggle("disabled", disabled);
+      let arrowButtons = document.querySelectorAll("button.arrowhead");
+      for (let button of arrowButtons) {
+        button.disabled = disabled;
+      }
+
+      // Notify observers that the TP UI has been updated.
+      // This is needed since our tests need to be notified about the
+      // trackingProtectionMenu element getting disabled/enabled at the right time.
+      Services.obs.notifyObservers(window, "privacy-pane-tp-ui-updated");
+    }
+
+    let policy = Services.policies.getActivePolicies();
+    if (
+      policy &&
+      ((policy.EnableTrackingProtection &&
+        policy.EnableTrackingProtection.Locked) ||
+        (policy.Cookies && policy.Cookies.Locked))
+    ) {
+      setInputsDisabledState(true);
+    }
+    if (tPPrefisLocked) {
+      // An extension can't control this setting if either pref is locked.
+      hideControllingExtension(TRACKING_PROTECTION_KEY);
+      setInputsDisabledState(false);
+    } else {
+      handleControllingExtension(
+        PREF_SETTING_TYPE,
+        TRACKING_PROTECTION_KEY
+      ).then(setInputsDisabledState);
+    }
+  },
+
+  /**
+   * Hide the "Change Block List" link for trackers/tracking content in the
+   * custom Content Blocking/ETP panel. By default, it will not be visible.
+   */
+  _showCustomBlockList() {
+    let prefValue = Services.prefs.getBoolPref(
+      "browser.contentblocking.customBlockList.preferences.ui.enabled"
+    );
+    if (!prefValue) {
+      document.getElementById("changeBlockListLink").style.display = "none";
+    } else {
+      setEventListener("changeBlockListLink", "click", this.showBlockLists);
+    }
+  },
+
+  /**
+   * Set up handlers for showing and hiding controlling extension info
+   * for tracking protection.
+   */
+  _initTrackingProtectionExtensionControl() {
+    setEventListener(
+      "contentBlockingDisableTrackingProtectionExtension",
+      "command",
+      makeDisableControllingExtension(
+        PREF_SETTING_TYPE,
+        TRACKING_PROTECTION_KEY
+      )
+    );
+
+    let trackingProtectionObserver = {
+      observe(subject, topic, data) {
+        gPrivacyPane._updateTrackingProtectionUI();
+      },
+    };
+
+    for (let pref of TRACKING_PROTECTION_PREFS) {
+      Services.prefs.addObserver(pref, trackingProtectionObserver);
+    }
+    window.addEventListener("unload", () => {
+      for (let pref of TRACKING_PROTECTION_PREFS) {
+        Services.prefs.removeObserver(pref, trackingProtectionObserver);
+      }
+    });
+  },
+
+  _initThirdPartyCertsToggle() {
+    // Third-party certificate import is only implemented for Windows and Mac,
+    // and we should not expose this as a user-configurable setting if there's
+    // an enterprise policy controlling it (either to enable _or_ disable it).
+    let canConfigureThirdPartyCerts =
+      (AppConstants.platform == "win" || AppConstants.platform == "macosx") &&
+      typeof Services.policies.getActivePolicies()?.Certificates
+        ?.ImportEnterpriseRoots == "undefined";
+
+    document.getElementById("certEnableThirdPartyToggleBox").hidden =
+      !canConfigureThirdPartyCerts;
+  },
+
+  syncFromHttpsOnlyPref() {
+    let httpsOnlyOnPref = Services.prefs.getBoolPref(
+      "dom.security.https_only_mode"
+    );
+    let httpsOnlyOnPBMPref = Services.prefs.getBoolPref(
+      "dom.security.https_only_mode_pbm"
+    );
+    let httpsFirstOnPref = Services.prefs.getBoolPref(
+      "dom.security.https_first"
+    );
+    let httpsFirstOnPBMPref = Services.prefs.getBoolPref(
+      "dom.security.https_first_pbm"
+    );
+    let httpsOnlyRadioGroup = document.getElementById("httpsOnlyRadioGroup");
+    let httpsOnlyExceptionButton = document.getElementById(
+      "httpsOnlyExceptionButton"
+    );
+
+    if (httpsOnlyOnPref) {
+      httpsOnlyRadioGroup.value = "enabled";
+    } else if (httpsOnlyOnPBMPref) {
+      httpsOnlyRadioGroup.value = "privateOnly";
+    } else {
+      httpsOnlyRadioGroup.value = "disabled";
+    }
+
+    httpsOnlyExceptionButton.disabled =
+      !httpsOnlyOnPref &&
+      !httpsFirstOnPref &&
+      !httpsOnlyOnPBMPref &&
+      !httpsFirstOnPBMPref;
+
+    if (
+      Services.prefs.prefIsLocked("dom.security.https_only_mode") ||
+      Services.prefs.prefIsLocked("dom.security.https_only_mode_pbm")
+    ) {
+      httpsOnlyRadioGroup.disabled = true;
+    }
+  },
+
+  syncToHttpsOnlyPref() {
+    let value = document.getElementById("httpsOnlyRadioGroup").value;
+    Services.prefs.setBoolPref(
+      "dom.security.https_only_mode_pbm",
+      value == "privateOnly"
+    );
+    Services.prefs.setBoolPref(
+      "dom.security.https_only_mode",
+      value == "enabled"
+    );
+  },
+
+  /**
+   * Init HTTPS-Only mode and corresponding prefs
+   */
+  initHttpsOnly() {
+    // Set radio-value based on the pref value
+    this.syncFromHttpsOnlyPref();
+
+    // Create event listener for when the user clicks
+    // on one of the radio buttons
+    setEventListener(
+      "httpsOnlyRadioGroup",
+      "command",
+      this.syncToHttpsOnlyPref
+    );
+    // Update radio-value when the pref changes
+    Preferences.get("dom.security.https_only_mode").on("change", () =>
+      this.syncFromHttpsOnlyPref()
+    );
+    Preferences.get("dom.security.https_only_mode_pbm").on("change", () =>
+      this.syncFromHttpsOnlyPref()
+    );
+    Preferences.get("dom.security.https_first").on("change", () =>
+      this.syncFromHttpsOnlyPref()
+    );
+    Preferences.get("dom.security.https_first_pbm").on("change", () =>
+      this.syncFromHttpsOnlyPref()
+    );
+  },
+
+  get dnsOverHttpsResolvers() {
+    let providers = DoHConfigController.currentConfig.providerList;
+    // if there's no default, we'll hold its position with an empty string
+    let defaultURI = DoHConfigController.currentConfig.fallbackProviderURI;
+    let defaultIndex = providers.findIndex(p => p.uri == defaultURI);
+    if (defaultIndex == -1 && defaultURI) {
+      // the default value for the pref isn't included in the resolvers list
+      // so we'll make a stub for it. Without an id, we'll have to use the url as the label
+      providers.unshift({ uri: defaultURI });
+    }
+    return providers;
+  },
+
+  updateDoHResolverList(mode) {
+    let resolvers = this.dnsOverHttpsResolvers;
+    let currentURI = Preferences.get("network.trr.uri").value;
+    if (!currentURI) {
+      currentURI = Preferences.get("network.trr.default_provider_uri").value;
+    }
+    let menu = document.getElementById(`${mode}ResolverChoices`);
+
+    let selectedIndex = currentURI
+      ? resolvers.findIndex(r => r.uri == currentURI)
+      : 0;
+    if (selectedIndex == -1) {
+      // select the last "Custom" item
+      selectedIndex = menu.itemCount - 1;
+    }
+    menu.selectedIndex = selectedIndex;
+
+    let customInput = document.getElementById(`${mode}InputField`);
+    customInput.hidden = menu.value != "custom";
+  },
+
+  populateDoHResolverList(mode) {
+    let resolvers = this.dnsOverHttpsResolvers;
+    let defaultURI = DoHConfigController.currentConfig.fallbackProviderURI;
+    let menu = document.getElementById(`${mode}ResolverChoices`);
+
+    // populate the DNS-Over-HTTPS resolver list
+    menu.removeAllItems();
+    for (let resolver of resolvers) {
+      let item = menu.appendItem(undefined, resolver.uri);
+      if (resolver.uri == defaultURI) {
+        document.l10n.setAttributes(
+          item,
+          "connection-dns-over-https-url-item-default",
+          {
+            name: resolver.UIName || resolver.uri,
+          }
+        );
+      } else {
+        item.label = resolver.UIName || resolver.uri;
+      }
+    }
+    let lastItem = menu.appendItem(undefined, "custom");
+    document.l10n.setAttributes(
+      lastItem,
+      "connection-dns-over-https-url-custom"
+    );
+
+    // set initial selection in the resolver provider picker
+    this.updateDoHResolverList(mode);
+
+    let customInput = document.getElementById(`${mode}InputField`);
+
+    function updateURIPref() {
+      if (customInput.value == "") {
+        // Setting the pref to empty string will make it have the default
+        // pref value which makes us fallback to using the default TRR
+        // resolver in network.trr.default_provider_uri.
+        // If the input is empty we set it to "(space)" which is essentially
+        // the same.
+        Services.prefs.setStringPref("network.trr.uri", " ");
+      } else {
+        Services.prefs.setStringPref("network.trr.uri", customInput.value);
+      }
+    }
+
+    menu.addEventListener("command", () => {
+      if (menu.value == "custom") {
+        customInput.hidden = false;
+        updateURIPref();
+      } else {
+        customInput.hidden = true;
+        Services.prefs.setStringPref("network.trr.uri", menu.value);
+      }
+      Services.telemetry.recordEvent(
+        "security.doh.settings",
+        "provider_choice",
+        "value",
+        menu.value
+      );
+
+      // Update other menu too.
+      let otherMode = mode == "dohEnabled" ? "dohStrict" : "dohEnabled";
+      let otherMenu = document.getElementById(`${otherMode}ResolverChoices`);
+      let otherInput = document.getElementById(`${otherMode}InputField`);
+      otherMenu.value = menu.value;
+      otherInput.hidden = otherMenu.value != "custom";
+    });
+
+    // Change the URL when you press ENTER in the input field it or loses focus
+    customInput.addEventListener("change", () => {
+      updateURIPref();
+    });
+  },
+
+  async updateDoHStatus() {
+    let trrURI = Services.dns.currentTrrURI;
+    let hostname = "";
+    try {
+      hostname = new URL(trrURI).hostname;
+    } catch (e) {
+      hostname = await document.l10n.formatValue("preferences-doh-bad-url");
+    }
+
+    let steering = document.getElementById("dohSteeringStatus");
+    steering.hidden = true;
+
+    let dohResolver = document.getElementById("dohResolver");
+    dohResolver.hidden = true;
+
+    let status = document.getElementById("dohStatus");
+
+    async function setStatus(localizedStringName, options) {
+      let opts = options || {};
+      let statusString = await document.l10n.formatValue(
+        localizedStringName,
+        opts
+      );
+      document.l10n.setAttributes(status, "preferences-doh-status", {
+        status: statusString,
+      });
+    }
+
+    function computeStatus() {
+      let mode = Services.dns.currentTrrMode;
+      let confirmationState = Services.dns.currentTrrConfirmationState;
+      if (
+        mode == Ci.nsIDNSService.MODE_TRRFIRST ||
+        mode == Ci.nsIDNSService.MODE_TRRONLY
+      ) {
+        switch (confirmationState) {
+          case Ci.nsIDNSService.CONFIRM_TRYING_OK:
+          case Ci.nsIDNSService.CONFIRM_OK:
+          case Ci.nsIDNSService.CONFIRM_DISABLED:
+            return "preferences-doh-status-active";
+          default:
+            return "preferences-doh-status-not-active";
+        }
+      }
+
+      return "preferences-doh-status-disabled";
+    }
+
+    let errReason = "";
+    let confirmationStatus = Services.dns.lastConfirmationStatus;
+    if (confirmationStatus != Cr.NS_OK) {
+      errReason = ChromeUtils.getXPCOMErrorName(confirmationStatus);
+    } else {
+      errReason = Services.dns.getTRRSkipReasonName(
+        Services.dns.lastConfirmationSkipReason
+      );
+    }
+    let statusLabel = computeStatus();
+    // setStatus will format and set the statusLabel asynchronously.
+    setStatus(statusLabel, { reason: errReason });
+    dohResolver.hidden = statusLabel == "preferences-doh-status-disabled";
+
+    let statusLearnMore = document.getElementById("dohStatusLearnMore");
+    statusLearnMore.hidden = statusLabel != "preferences-doh-status-not-active";
+
+    // No need to set the resolver name since we're not going to show it.
+    if (statusLabel == "preferences-doh-status-disabled") {
+      return;
+    }
+
+    function nameOrDomain() {
+      for (let resolver of DoHConfigController.currentConfig.providerList) {
+        if (resolver.uri == trrURI) {
+          return resolver.UIName || hostname || trrURI;
+        }
+      }
+
+      // Also check if this is a steering provider.
+      for (let resolver of DoHConfigController.currentConfig.providerSteering
+        .providerList) {
+        if (resolver.uri == trrURI) {
+          steering.hidden = false;
+          return resolver.UIName || hostname || trrURI;
+        }
+      }
+
+      return hostname;
+    }
+
+    let resolverNameOrDomain = nameOrDomain();
+    document.l10n.setAttributes(dohResolver, "preferences-doh-resolver", {
+      name: resolverNameOrDomain,
+    });
+  },
+
+  highlightDoHCategoryAndUpdateStatus() {
+    let value = Preferences.get("network.trr.mode").value;
+    let defaultOption = document.getElementById("dohOptionDefault");
+    let enabledOption = document.getElementById("dohOptionEnabled");
+    let strictOption = document.getElementById("dohOptionStrict");
+    let offOption = document.getElementById("dohOptionOff");
+    defaultOption.classList.remove("selected");
+    enabledOption.classList.remove("selected");
+    strictOption.classList.remove("selected");
+    offOption.classList.remove("selected");
+
+    switch (value) {
+      case Ci.nsIDNSService.MODE_NATIVEONLY:
+        defaultOption.classList.add("selected");
+        break;
+      case Ci.nsIDNSService.MODE_TRRFIRST:
+        enabledOption.classList.add("selected");
+        break;
+      case Ci.nsIDNSService.MODE_TRRONLY:
+        strictOption.classList.add("selected");
+        break;
+      case Ci.nsIDNSService.MODE_TRROFF:
+        offOption.classList.add("selected");
+        break;
+      default:
+        // The pref is set to a random value.
+        // This shouldn't happen, but let's make sure off is selected.
+        offOption.classList.add("selected");
+        document.getElementById("dohCategoryRadioGroup").selectedIndex = 3;
+        break;
+    }
+
+    // When the mode is set to 0 we need to clear the URI so
+    // doh-rollout can kick in.
+    if (value == Ci.nsIDNSService.MODE_NATIVEONLY) {
+      Services.prefs.clearUserPref("network.trr.uri");
+      Services.prefs.clearUserPref("doh-rollout.disable-heuristics");
+    }
+
+    gPrivacyPane.updateDoHStatus();
+  },
+
+  /**
+   * Init DoH corresponding prefs
+   */
+  initDoH() {
+    Services.telemetry.setEventRecordingEnabled("security.doh.settings", true);
+
+    setEventListener("dohDefaultArrow", "command", this.toggleExpansion);
+    setEventListener("dohEnabledArrow", "command", this.toggleExpansion);
+    setEventListener("dohStrictArrow", "command", this.toggleExpansion);
+
+    function modeButtonPressed(e) {
+      // Clicking the active mode again should not generate another event
+      if (
+        parseInt(e.target.value) == Preferences.get("network.trr.mode").value
+      ) {
+        return;
+      }
+      Services.telemetry.recordEvent(
+        "security.doh.settings",
+        "mode_changed",
+        "button",
+        e.target.id
+      );
+    }
+
+    setEventListener("dohDefaultRadio", "command", modeButtonPressed);
+    setEventListener("dohEnabledRadio", "command", modeButtonPressed);
+    setEventListener("dohStrictRadio", "command", modeButtonPressed);
+    setEventListener("dohOffRadio", "command", modeButtonPressed);
+
+    function warnCheckboxClicked(e) {
+      Services.telemetry.recordEvent(
+        "security.doh.settings",
+        "warn_checkbox",
+        "checkbox",
+        `${e.target.checked}`
+      );
+    }
+
+    setEventListener("dohWarnCheckbox1", "command", warnCheckboxClicked);
+    setEventListener("dohWarnCheckbox2", "command", warnCheckboxClicked);
+
+    this.populateDoHResolverList("dohEnabled");
+    this.populateDoHResolverList("dohStrict");
+
+    Preferences.get("network.trr.uri").on("change", () => {
+      gPrivacyPane.updateDoHResolverList("dohEnabled");
+      gPrivacyPane.updateDoHResolverList("dohStrict");
+      gPrivacyPane.updateDoHStatus();
+    });
+
+    // Update status box and hightlightling when the pref changes
+    Preferences.get("network.trr.mode").on(
+      "change",
+      gPrivacyPane.highlightDoHCategoryAndUpdateStatus
+    );
+    this.highlightDoHCategoryAndUpdateStatus();
+
+    Services.obs.addObserver(this, "network:trr-uri-changed");
+    Services.obs.addObserver(this, "network:trr-mode-changed");
+    Services.obs.addObserver(this, "network:trr-confirmation");
+    let unload = () => {
+      Services.obs.removeObserver(this, "network:trr-uri-changed");
+      Services.obs.removeObserver(this, "network:trr-mode-changed");
+      Services.obs.removeObserver(this, "network:trr-confirmation");
+    };
+    window.addEventListener("unload", unload, { once: true });
+
+    if (Preferences.get("network.trr_ui.show_fallback_warning_option").value) {
+      document.getElementById("dohWarningBox1").hidden = false;
+      document.getElementById("dohWarningBox2").hidden = false;
+    }
+
+    let uriPref = Services.prefs.getStringPref("network.trr.uri");
+    // If the value isn't one of the providers, we need to update the
+    // custom_uri pref to make sure the input box contains the correct URL.
+    if (uriPref && !this.dnsOverHttpsResolvers.some(e => e.uri == uriPref)) {
+      Services.prefs.setStringPref(
+        "network.trr.custom_uri",
+        Services.prefs.getStringPref("network.trr.uri")
+      );
+    }
+
+    if (Services.prefs.prefIsLocked("network.trr.mode")) {
+      document.getElementById("dohCategoryRadioGroup").disabled = true;
+      Services.prefs.setStringPref("network.trr.custom_uri", uriPref);
+    }
+  },
+
+  initWebAuthn() {
+    document.getElementById("openWindowsPasskeySettings").hidden =
+      !Services.prefs.getBoolPref(
+        "security.webauthn.show_ms_settings_link",
+        true
+      );
+  },
+
+  /**
+   * Sets up the UI for the number of days of history to keep, and updates the
+   * label of the "Clear Now..." button.
+   */
+  init() {
+    this._updateSanitizeSettingsButton();
+    this.initDeleteOnCloseBox();
+    this.syncSanitizationPrefsWithDeleteOnClose();
+    this.initializeHistoryMode();
+    this.updateHistoryModePane();
+    this.updatePrivacyMicroControls();
+    this.initAutoStartPrivateBrowsingReverter();
+
+    /* Initialize Content Blocking */
+    this.initContentBlocking();
+
+    this._showCustomBlockList();
+    this.trackingProtectionReadPrefs();
+    this.fingerprintingProtectionReadPrefs();
+    this.networkCookieBehaviorReadPrefs();
+    this._initTrackingProtectionExtensionControl();
+    this._initThirdPartyCertsToggle();
+
+    Services.telemetry.setEventRecordingEnabled("privacy.ui.fpp", true);
+
+    Services.telemetry.setEventRecordingEnabled("pwmgr", true);
+
+    Preferences.get("privacy.trackingprotection.enabled").on(
+      "change",
+      gPrivacyPane.trackingProtectionReadPrefs.bind(gPrivacyPane)
+    );
+    Preferences.get("privacy.trackingprotection.pbmode.enabled").on(
+      "change",
+      gPrivacyPane.trackingProtectionReadPrefs.bind(gPrivacyPane)
+    );
+
+    // Watch all of the prefs that the new Cookies & Site Data UI depends on
+    Preferences.get("network.cookie.cookieBehavior").on(
+      "change",
+      gPrivacyPane.networkCookieBehaviorReadPrefs.bind(gPrivacyPane)
+    );
+    Preferences.get("browser.privatebrowsing.autostart").on(
+      "change",
+      gPrivacyPane.networkCookieBehaviorReadPrefs.bind(gPrivacyPane)
+    );
+    Preferences.get("privacy.firstparty.isolate").on(
+      "change",
+      gPrivacyPane.networkCookieBehaviorReadPrefs.bind(gPrivacyPane)
+    );
+
+    Preferences.get("privacy.fingerprintingProtection").on(
+      "change",
+      gPrivacyPane.fingerprintingProtectionReadPrefs.bind(gPrivacyPane)
+    );
+    Preferences.get("privacy.fingerprintingProtection.pbmode").on(
+      "change",
+      gPrivacyPane.fingerprintingProtectionReadPrefs.bind(gPrivacyPane)
+    );
+
+    setEventListener(
+      "trackingProtectionExceptions",
+      "command",
+      gPrivacyPane.showTrackingProtectionExceptions
+    );
+
+    Preferences.get("privacy.sanitize.sanitizeOnShutdown").on(
+      "change",
+      gPrivacyPane._updateSanitizeSettingsButton.bind(gPrivacyPane)
+    );
+    Preferences.get("browser.privatebrowsing.autostart").on(
+      "change",
+      gPrivacyPane.updatePrivacyMicroControls.bind(gPrivacyPane)
+    );
+    setEventListener("historyMode", "command", function () {
+      gPrivacyPane.updateHistoryModePane();
+      gPrivacyPane.updateHistoryModePrefs();
+      gPrivacyPane.updatePrivacyMicroControls();
+      gPrivacyPane.updateAutostart();
+    });
+    setEventListener("clearHistoryButton", "command", function () {
+      let historyMode = document.getElementById("historyMode");
+      // Select "everything" in the clear history dialog if the
+      // user has set their history mode to never remember history.
+      gPrivacyPane.clearPrivateDataNow(historyMode.value == "dontremember");
+    });
+    setEventListener(
+      "privateBrowsingAutoStart",
+      "command",
+      gPrivacyPane.updateAutostart
+    );
+    setEventListener(
+      "cookieExceptions",
+      "command",
+      gPrivacyPane.showCookieExceptions
+    );
+    setEventListener(
+      "httpsOnlyExceptionButton",
+      "command",
+      gPrivacyPane.showHttpsOnlyModeExceptions
+    );
+    setEventListener(
+      "dohExceptionsButton",
+      "command",
+      gPrivacyPane.showDoHExceptions
+    );
+    setEventListener(
+      "clearDataSettings",
+      "command",
+      gPrivacyPane.showClearPrivateDataSettings
+    );
+    setEventListener(
+      "passwordExceptions",
+      "command",
+      gPrivacyPane.showPasswordExceptions
+    );
+    setEventListener(
+      "useMasterPassword",
+      "command",
+      gPrivacyPane.updateMasterPasswordButton
+    );
+    setEventListener(
+      "changeMasterPassword",
+      "command",
+      gPrivacyPane.changeMasterPassword
+    );
+    setEventListener("showPasswords", "command", gPrivacyPane.showPasswords);
+    setEventListener(
+      "addonExceptions",
+      "command",
+      gPrivacyPane.showAddonExceptions
+    );
+    setEventListener(
+      "viewCertificatesButton",
+      "command",
+      gPrivacyPane.showCertificates
+    );
+    setEventListener(
+      "viewSecurityDevicesButton",
+      "command",
+      gPrivacyPane.showSecurityDevices
+    );
+
+    this._pane = document.getElementById("panePrivacy");
+
+    this._initGlobalPrivacyControlUI();
+    this._initPasswordGenerationUI();
+    this._initRelayIntegrationUI();
+    this._initMasterPasswordUI();
+
+    this.initListenersForExtensionControllingPasswordManager();
+
+    this._initSafeBrowsing();
+
+    setEventListener(
+      "autoplaySettingsButton",
+      "command",
+      gPrivacyPane.showAutoplayMediaExceptions
+    );
+    setEventListener(
+      "notificationSettingsButton",
+      "command",
+      gPrivacyPane.showNotificationExceptions
+    );
+    setEventListener(
+      "locationSettingsButton",
+      "command",
+      gPrivacyPane.showLocationExceptions
+    );
+    setEventListener(
+      "xrSettingsButton",
+      "command",
+      gPrivacyPane.showXRExceptions
+    );
+    setEventListener(
+      "cameraSettingsButton",
+      "command",
+      gPrivacyPane.showCameraExceptions
+    );
+    setEventListener(
+      "microphoneSettingsButton",
+      "command",
+      gPrivacyPane.showMicrophoneExceptions
+    );
+    document.getElementById("speakerSettingsRow").hidden =
+      !Services.prefs.getBoolPref("media.setsinkid.enabled", false);
+    setEventListener(
+      "speakerSettingsButton",
+      "command",
+      gPrivacyPane.showSpeakerExceptions
+    );
+    setEventListener(
+      "popupPolicyButton",
+      "command",
+      gPrivacyPane.showPopupExceptions
+    );
+    setEventListener(
+      "notificationsDoNotDisturb",
+      "command",
+      gPrivacyPane.toggleDoNotDisturbNotifications
+    );
+
+    setSyncFromPrefListener("contentBlockingBlockCookiesCheckbox", () =>
+      this.readBlockCookies()
+    );
+    setSyncToPrefListener("contentBlockingBlockCookiesCheckbox", () =>
+      this.writeBlockCookies()
+    );
+    setSyncFromPrefListener("blockCookiesMenu", () =>
+      this.readBlockCookiesFrom()
+    );
+    setSyncToPrefListener("blockCookiesMenu", () =>
+      this.writeBlockCookiesFrom()
+    );
+
+    setSyncFromPrefListener("savePasswords", () => this.readSavePasswords());
+
+    let microControlHandler = el =>
+      this.ensurePrivacyMicroControlUncheckedWhenDisabled(el);
+    setSyncFromPrefListener("rememberHistory", microControlHandler);
+    setSyncFromPrefListener("rememberForms", microControlHandler);
+    setSyncFromPrefListener("alwaysClear", microControlHandler);
+
+    setSyncFromPrefListener("popupPolicy", () =>
+      this.updateButtons("popupPolicyButton", "dom.disable_open_during_load")
+    );
+    setSyncFromPrefListener("warnAddonInstall", () =>
+      this.readWarnAddonInstall()
+    );
+    setSyncFromPrefListener("enableOCSP", () => this.readEnableOCSP());
+    setSyncToPrefListener("enableOCSP", () => this.writeEnableOCSP());
+
+    if (AlertsServiceDND) {
+      let notificationsDoNotDisturbBox = document.getElementById(
+        "notificationsDoNotDisturbBox"
+      );
+      notificationsDoNotDisturbBox.removeAttribute("hidden");
+      let checkbox = document.getElementById("notificationsDoNotDisturb");
+      document.l10n.setAttributes(checkbox, "permissions-notification-pause");
+      if (AlertsServiceDND.manualDoNotDisturb) {
+        let notificationsDoNotDisturb = document.getElementById(
+          "notificationsDoNotDisturb"
+        );
+        notificationsDoNotDisturb.setAttribute("checked", true);
+      }
+    }
+
+    let onNimbus = () => this._updateFirefoxSuggestToggle();
+    NimbusFeatures.urlbar.onUpdate(onNimbus);
+    this._updateFirefoxSuggestToggle(true);
+    window.addEventListener("unload", () => {
+      NimbusFeatures.urlbar.offUpdate(onNimbus);
+    });
+
+    this.initSiteDataControls();
+    setEventListener(
+      "clearSiteDataButton",
+      "command",
+      gPrivacyPane.clearSiteData
+    );
+    setEventListener(
+      "siteDataSettings",
+      "command",
+      gPrivacyPane.showSiteDataSettings
+    );
+
+    this.initCookieBannerHandling();
+
+    this.initDataCollection();
+
+    if (AppConstants.MOZ_DATA_REPORTING) {
+      if (AppConstants.MOZ_CRASHREPORTER) {
+        this.initSubmitCrashes();
+      }
+      this.initSubmitHealthReport();
+      setEventListener(
+        "submitHealthReportBox",
+        "command",
+        gPrivacyPane.updateSubmitHealthReport
+      );
+      setEventListener(
+        "telemetryDataDeletionLearnMore",
+        "click",
+        gPrivacyPane.showDataDeletion
+      );
+      if (AppConstants.MOZ_NORMANDY) {
+        this.initOptOutStudyCheckbox();
+      }
+      this.initAddonRecommendationsCheckbox();
+    }
+
+    let signonBundle = document.getElementById("signonBundle");
+    let pkiBundle = document.getElementById("pkiBundle");
+    appendSearchKeywords("showPasswords", [
+      signonBundle.getString("loginsDescriptionAll2"),
+    ]);
+    appendSearchKeywords("viewSecurityDevicesButton", [
+      pkiBundle.getString("enable_fips"),
+    ]);
+
+    if (!PrivateBrowsingUtils.enabled) {
+      document.getElementById("privateBrowsingAutoStart").hidden = true;
+      document.querySelector("menuitem[value='dontremember']").hidden = true;
+    }
+
+    /* init HTTPS-Only mode */
+    this.initHttpsOnly();
+
+    this.initDoH();
+
+    this.initWebAuthn();
+
+    // Notify observers that the UI is now ready
+    Services.obs.notifyObservers(window, "privacy-pane-loaded");
+  },
+
+  initSiteDataControls() {
+    Services.obs.addObserver(this, "sitedatamanager:sites-updated");
+    Services.obs.addObserver(this, "sitedatamanager:updating-sites");
+    let unload = () => {
+      window.removeEventListener("unload", unload);
+      Services.obs.removeObserver(this, "sitedatamanager:sites-updated");
+      Services.obs.removeObserver(this, "sitedatamanager:updating-sites");
+    };
+    window.addEventListener("unload", unload);
+    SiteDataManager.updateSites();
+  },
+
+  // CONTENT BLOCKING
+
+  /**
+   * Initializes the content blocking section.
+   */
+  initContentBlocking() {
+    setEventListener(
+      "contentBlockingTrackingProtectionCheckbox",
+      "command",
+      this.trackingProtectionWritePrefs
+    );
+    setEventListener(
+      "contentBlockingTrackingProtectionCheckbox",
+      "command",
+      this._updateTrackingProtectionUI
+    );
+    setEventListener(
+      "contentBlockingCryptominersCheckbox",
+      "command",
+      this.updateCryptominingLists
+    );
+    setEventListener(
+      "contentBlockingFingerprintersCheckbox",
+      "command",
+      this.updateFingerprintingLists
+    );
+    setEventListener(
+      "trackingProtectionMenu",
+      "command",
+      this.trackingProtectionWritePrefs
+    );
+    setEventListener(
+      "contentBlockingFingerprintingProtectionCheckbox",
+      "command",
+      e => {
+        const extra = { checked: e.target.checked };
+        Glean.privacyUiFppClick.checkbox.record(extra);
+        this.fingerprintingProtectionWritePrefs();
+      }
+    );
+    setEventListener("fingerprintingProtectionMenu", "command", e => {
+      const extra = { value: e.target.value };
+      Glean.privacyUiFppClick.menu.record(extra);
+      this.fingerprintingProtectionWritePrefs();
+    });
+    setEventListener("standardArrow", "command", this.toggleExpansion);
+    setEventListener("strictArrow", "command", this.toggleExpansion);
+    setEventListener("customArrow", "command", this.toggleExpansion);
+
+    Preferences.get("network.cookie.cookieBehavior").on(
+      "change",
+      gPrivacyPane.readBlockCookies.bind(gPrivacyPane)
+    );
+    Preferences.get("browser.contentblocking.category").on(
+      "change",
+      gPrivacyPane.highlightCBCategory
+    );
+
+    // If any relevant content blocking pref changes, show a warning that the changes will
+    // not be implemented until they refresh their tabs.
+    for (let pref of CONTENT_BLOCKING_PREFS) {
+      Preferences.get(pref).on("change", gPrivacyPane.maybeNotifyUserToReload);
+      // If the value changes, run populateCategoryContents, since that change might have been
+      // triggered by a default value changing in the standard category.
+      Preferences.get(pref).on("change", gPrivacyPane.populateCategoryContents);
+    }
+    Preferences.get("urlclassifier.trackingTable").on(
+      "change",
+      gPrivacyPane.maybeNotifyUserToReload
+    );
+    for (let button of document.querySelectorAll(".reload-tabs-button")) {
+      button.addEventListener("command", gPrivacyPane.reloadAllOtherTabs);
+    }
+
+    let cryptoMinersOption = document.getElementById(
+      "contentBlockingCryptominersOption"
+    );
+    let fingerprintersOption = document.getElementById(
+      "contentBlockingFingerprintersOption"
+    );
+    let trackingAndIsolateOption = document.querySelector(
+      "#blockCookiesMenu menuitem[value='trackers-plus-isolate']"
+    );
+    cryptoMinersOption.hidden = !Services.prefs.getBoolPref(
+      "browser.contentblocking.cryptomining.preferences.ui.enabled"
+    );
+    fingerprintersOption.hidden = !Services.prefs.getBoolPref(
+      "browser.contentblocking.fingerprinting.preferences.ui.enabled"
+    );
+    let updateTrackingAndIsolateOption = () => {
+      trackingAndIsolateOption.hidden =
+        !Services.prefs.getBoolPref(
+          "browser.contentblocking.reject-and-isolate-cookies.preferences.ui.enabled",
+          false
+        ) || gIsFirstPartyIsolated;
+    };
+    Preferences.get("privacy.firstparty.isolate").on(
+      "change",
+      updateTrackingAndIsolateOption
+    );
+    updateTrackingAndIsolateOption();
+
+    Preferences.get("browser.contentblocking.features.strict").on(
+      "change",
+      this.populateCategoryContents
+    );
+    this.populateCategoryContents();
+    this.highlightCBCategory();
+    this.readBlockCookies();
+
+    // Toggles the text "Cross-site and social media trackers" based on the
+    // social tracking pref. If the pref is false, the text reads
+    // "Cross-site trackers".
+    const STP_COOKIES_PREF = "privacy.socialtracking.block_cookies.enabled";
+    if (Services.prefs.getBoolPref(STP_COOKIES_PREF)) {
+      let contentBlockOptionSocialMedia = document.getElementById(
+        "blockCookiesSocialMedia"
+      );
+
+      document.l10n.setAttributes(
+        contentBlockOptionSocialMedia,
+        "sitedata-option-block-cross-site-tracking-cookies"
+      );
+    }
+
+    Preferences.get("privacy.resistFingerprinting").on(
+      "change",
+      setUpContentBlockingWarnings
+    );
+    Preferences.get("privacy.resistFingerprinting.pbmode").on(
+      "change",
+      setUpContentBlockingWarnings
+    );
+
+    setUpContentBlockingWarnings();
+
+    initTCPStandardSection();
+  },
+
+  populateCategoryContents() {
+    for (let type of ["strict", "standard"]) {
+      let rulesArray = [];
+      let selector;
+      if (type == "strict") {
+        selector = "#contentBlockingOptionStrict";
+        rulesArray = Services.prefs
+          .getStringPref("browser.contentblocking.features.strict")
+          .split(",");
+        if (gIsFirstPartyIsolated) {
+          let idx = rulesArray.indexOf("cookieBehavior5");
+          if (idx != -1) {
+            rulesArray[idx] = "cookieBehavior4";
+          }
+        }
+      } else {
+        selector = "#contentBlockingOptionStandard";
+        // In standard show/hide UI items based on the default values of the relevant prefs.
+        let defaults = Services.prefs.getDefaultBranch("");
+
+        let cookieBehavior = defaults.getIntPref(
+          "network.cookie.cookieBehavior"
+        );
+        switch (cookieBehavior) {
+          case Ci.nsICookieService.BEHAVIOR_ACCEPT:
+            rulesArray.push("cookieBehavior0");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN:
+            rulesArray.push("cookieBehavior1");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT:
+            rulesArray.push("cookieBehavior2");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_LIMIT_FOREIGN:
+            rulesArray.push("cookieBehavior3");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER:
+            rulesArray.push("cookieBehavior4");
+            break;
+          case BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN:
+            rulesArray.push(
+              gIsFirstPartyIsolated ? "cookieBehavior4" : "cookieBehavior5"
+            );
+            break;
+        }
+        let cookieBehaviorPBM = defaults.getIntPref(
+          "network.cookie.cookieBehavior.pbmode"
+        );
+        switch (cookieBehaviorPBM) {
+          case Ci.nsICookieService.BEHAVIOR_ACCEPT:
+            rulesArray.push("cookieBehaviorPBM0");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN:
+            rulesArray.push("cookieBehaviorPBM1");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT:
+            rulesArray.push("cookieBehaviorPBM2");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_LIMIT_FOREIGN:
+            rulesArray.push("cookieBehaviorPBM3");
+            break;
+          case Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER:
+            rulesArray.push("cookieBehaviorPBM4");
+            break;
+          case BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN:
+            rulesArray.push(
+              gIsFirstPartyIsolated
+                ? "cookieBehaviorPBM4"
+                : "cookieBehaviorPBM5"
+            );
+            break;
+        }
+        rulesArray.push(
+          defaults.getBoolPref(
+            "privacy.trackingprotection.cryptomining.enabled"
+          )
+            ? "cm"
+            : "-cm"
+        );
+        rulesArray.push(
+          defaults.getBoolPref(
+            "privacy.trackingprotection.fingerprinting.enabled"
+          )
+            ? "fp"
+            : "-fp"
+        );
+        rulesArray.push(
+          Services.prefs.getBoolPref(
+            "privacy.socialtracking.block_cookies.enabled"
+          )
+            ? "stp"
+            : "-stp"
+        );
+        rulesArray.push(
+          defaults.getBoolPref("privacy.trackingprotection.enabled")
+            ? "tp"
+            : "-tp"
+        );
+        rulesArray.push(
+          defaults.getBoolPref("privacy.trackingprotection.pbmode.enabled")
+            ? "tpPrivate"
+            : "-tpPrivate"
+        );
+      }
+
+      // Hide all cookie options first, until we learn which one should be showing.
+      document.querySelector(selector + " .all-cookies-option").hidden = true;
+      document.querySelector(
+        selector + " .unvisited-cookies-option"
+      ).hidden = true;
+      document.querySelector(
+        selector + " .cross-site-cookies-option"
+      ).hidden = true;
+      document.querySelector(
+        selector + " .third-party-tracking-cookies-option"
+      ).hidden = true;
+      document.querySelector(
+        selector + " .all-third-party-cookies-private-windows-option"
+      ).hidden = true;
+      document.querySelector(
+        selector + " .all-third-party-cookies-option"
+      ).hidden = true;
+      document.querySelector(selector + " .social-media-option").hidden = true;
+
+      for (let item of rulesArray) {
+        // Note "cookieBehavior0", will result in no UI changes, so is not listed here.
+        switch (item) {
+          case "tp":
+            document.querySelector(
+              selector + " .trackers-option"
+            ).hidden = false;
+            break;
+          case "-tp":
+            document.querySelector(
+              selector + " .trackers-option"
+            ).hidden = true;
+            break;
+          case "tpPrivate":
+            document.querySelector(
+              selector + " .pb-trackers-option"
+            ).hidden = false;
+            break;
+          case "-tpPrivate":
+            document.querySelector(
+              selector + " .pb-trackers-option"
+            ).hidden = true;
+            break;
+          case "fp":
+            document.querySelector(
+              selector + " .fingerprinters-option"
+            ).hidden = false;
+            break;
+          case "-fp":
+            document.querySelector(
+              selector + " .fingerprinters-option"
+            ).hidden = true;
+            break;
+          case "cm":
+            document.querySelector(
+              selector + " .cryptominers-option"
+            ).hidden = false;
+            break;
+          case "-cm":
+            document.querySelector(
+              selector + " .cryptominers-option"
+            ).hidden = true;
+            break;
+          case "stp":
+            // Store social tracking cookies pref
+            const STP_COOKIES_PREF =
+              "privacy.socialtracking.block_cookies.enabled";
+
+            if (Services.prefs.getBoolPref(STP_COOKIES_PREF)) {
+              document.querySelector(
+                selector + " .social-media-option"
+              ).hidden = false;
+            }
+            break;
+          case "-stp":
+            // Store social tracking cookies pref
+            document.querySelector(
+              selector + " .social-media-option"
+            ).hidden = true;
+            break;
+          case "cookieBehavior1":
+            document.querySelector(
+              selector + " .all-third-party-cookies-option"
+            ).hidden = false;
+            break;
+          case "cookieBehavior2":
+            document.querySelector(
+              selector + " .all-cookies-option"
+            ).hidden = false;
+            break;
+          case "cookieBehavior3":
+            document.querySelector(
+              selector + " .unvisited-cookies-option"
+            ).hidden = false;
+            break;
+          case "cookieBehavior4":
+            document.querySelector(
+              selector + " .third-party-tracking-cookies-option"
+            ).hidden = false;
+            break;
+          case "cookieBehavior5":
+            document.querySelector(
+              selector + " .cross-site-cookies-option"
+            ).hidden = false;
+            break;
+          case "cookieBehaviorPBM5":
+            // We only need to show the cookie option for private windows if the
+            // cookieBehaviors are different between regular windows and private
+            // windows.
+            if (!rulesArray.includes("cookieBehavior5")) {
+              document.querySelector(
+                selector + " .all-third-party-cookies-private-windows-option"
+              ).hidden = false;
+            }
+            break;
+        }
+      }
+      // Hide the "tracking protection in private browsing" list item
+      // if the "tracking protection enabled in all windows" list item is showing.
+      if (!document.querySelector(selector + " .trackers-option").hidden) {
+        document.querySelector(selector + " .pb-trackers-option").hidden = true;
+      }
+    }
+  },
+
+  highlightCBCategory() {
+    let value = Preferences.get("browser.contentblocking.category").value;
+    let standardEl = document.getElementById("contentBlockingOptionStandard");
+    let strictEl = document.getElementById("contentBlockingOptionStrict");
+    let customEl = document.getElementById("contentBlockingOptionCustom");
+    standardEl.classList.remove("selected");
+    strictEl.classList.remove("selected");
+    customEl.classList.remove("selected");
+
+    switch (value) {
+      case "strict":
+        strictEl.classList.add("selected");
+        break;
+      case "custom":
+        customEl.classList.add("selected");
+        break;
+      case "standard":
+      /* fall through */
+      default:
+        standardEl.classList.add("selected");
+        break;
+    }
+  },
+
+  updateCryptominingLists() {
+    let listPrefs = [
+      "urlclassifier.features.cryptomining.blacklistTables",
+      "urlclassifier.features.cryptomining.whitelistTables",
+    ];
+
+    let listValue = listPrefs
+      .map(l => Services.prefs.getStringPref(l))
+      .join(",");
+    listManager.forceUpdates(listValue);
+  },
+
+  updateFingerprintingLists() {
+    let listPrefs = [
+      "urlclassifier.features.fingerprinting.blacklistTables",
+      "urlclassifier.features.fingerprinting.whitelistTables",
+    ];
+
+    let listValue = listPrefs
+      .map(l => Services.prefs.getStringPref(l))
+      .join(",");
+    listManager.forceUpdates(listValue);
+  },
+
+  // TRACKING PROTECTION MODE
+
+  /**
+   * Selects the right item of the Tracking Protection menulist and checkbox.
+   */
+  trackingProtectionReadPrefs() {
+    let enabledPref = Preferences.get("privacy.trackingprotection.enabled");
+    let pbmPref = Preferences.get("privacy.trackingprotection.pbmode.enabled");
+    let tpMenu = document.getElementById("trackingProtectionMenu");
+    let tpCheckbox = document.getElementById(
+      "contentBlockingTrackingProtectionCheckbox"
+    );
+
+    this._updateTrackingProtectionUI();
+
+    // Global enable takes precedence over enabled in Private Browsing.
+    if (enabledPref.value) {
+      tpMenu.value = "always";
+      tpCheckbox.checked = true;
+    } else if (pbmPref.value) {
+      tpMenu.value = "private";
+      tpCheckbox.checked = true;
+    } else {
+      tpMenu.value = "never";
+      tpCheckbox.checked = false;
+    }
+  },
+
+  /**
+   * Selects the right item of the Fingerprinting Protection menulist and
+   * checkbox.
+   */
+  fingerprintingProtectionReadPrefs() {
+    let enabledPref = Preferences.get("privacy.fingerprintingProtection");
+    let pbmPref = Preferences.get("privacy.fingerprintingProtection.pbmode");
+    let fppMenu = document.getElementById("fingerprintingProtectionMenu");
+    let fppCheckbox = document.getElementById(
+      "contentBlockingFingerprintingProtectionCheckbox"
+    );
+
+    // Global enable takes precedence over enabled in Private Browsing.
+    if (enabledPref.value) {
+      fppMenu.value = "always";
+      fppCheckbox.checked = true;
+    } else if (pbmPref.value) {
+      fppMenu.value = "private";
+      fppCheckbox.checked = true;
+    } else {
+      fppMenu.value = "never";
+      fppCheckbox.checked = false;
+    }
+    fppMenu.disabled = !fppCheckbox.checked;
+  },
+
+  /**
+   * Selects the right items of the new Cookies & Site Data UI.
+   */
+  networkCookieBehaviorReadPrefs() {
+    let behavior = Services.cookies.getCookieBehavior(false);
+    let blockCookiesMenu = document.getElementById("blockCookiesMenu");
+    let deleteOnCloseCheckbox = document.getElementById("deleteOnClose");
+    let deleteOnCloseNote = document.getElementById("deleteOnCloseNote");
+    let blockCookies = behavior != Ci.nsICookieService.BEHAVIOR_ACCEPT;
+    let cookieBehaviorLocked = Services.prefs.prefIsLocked(
+      "network.cookie.cookieBehavior"
+    );
+    let blockCookiesControlsDisabled = !blockCookies || cookieBehaviorLocked;
+    blockCookiesMenu.disabled = blockCookiesControlsDisabled;
+
+    let completelyBlockCookies =
+      behavior == Ci.nsICookieService.BEHAVIOR_REJECT;
+    let privateBrowsing = Preferences.get(
+      "browser.privatebrowsing.autostart"
+    ).value;
+    deleteOnCloseCheckbox.disabled = privateBrowsing || completelyBlockCookies;
+    deleteOnCloseNote.hidden = !privateBrowsing;
+
+    switch (behavior) {
+      case Ci.nsICookieService.BEHAVIOR_ACCEPT:
+        break;
+      case Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN:
+        blockCookiesMenu.value = "all-third-parties";
+        break;
+      case Ci.nsICookieService.BEHAVIOR_REJECT:
+        blockCookiesMenu.value = "always";
+        break;
+      case Ci.nsICookieService.BEHAVIOR_LIMIT_FOREIGN:
+        blockCookiesMenu.value = "unvisited";
+        break;
+      case Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER:
+        blockCookiesMenu.value = "trackers";
+        break;
+      case BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN:
+        blockCookiesMenu.value = "trackers-plus-isolate";
+        break;
+    }
+  },
+
+  /**
+   * Sets the pref values based on the selected item of the radiogroup.
+   */
+  trackingProtectionWritePrefs() {
+    let enabledPref = Preferences.get("privacy.trackingprotection.enabled");
+    let pbmPref = Preferences.get("privacy.trackingprotection.pbmode.enabled");
+    let stpPref = Preferences.get(
+      "privacy.trackingprotection.socialtracking.enabled"
+    );
+    let stpCookiePref = Preferences.get(
+      "privacy.socialtracking.block_cookies.enabled"
+    );
+    // Currently, we don't expose the email tracking protection setting on our
+    // privacy UI. Instead, we use the existing tracking protection checkbox to
+    // control the email tracking protection.
+    let emailTPPref = Preferences.get(
+      "privacy.trackingprotection.emailtracking.enabled"
+    );
+    let emailTPPBMPref = Preferences.get(
+      "privacy.trackingprotection.emailtracking.pbmode.enabled"
+    );
+    let tpMenu = document.getElementById("trackingProtectionMenu");
+    let tpCheckbox = document.getElementById(
+      "contentBlockingTrackingProtectionCheckbox"
+    );
+
+    let value;
+    if (tpCheckbox.checked) {
+      if (tpMenu.value == "never") {
+        tpMenu.value = "private";
+      }
+      value = tpMenu.value;
+    } else {
+      tpMenu.value = "never";
+      value = "never";
+    }
+
+    switch (value) {
+      case "always":
+        enabledPref.value = true;
+        pbmPref.value = true;
+        emailTPPref.value = true;
+        emailTPPBMPref.value = true;
+        if (stpCookiePref.value) {
+          stpPref.value = true;
+        }
+        break;
+      case "private":
+        enabledPref.value = false;
+        pbmPref.value = true;
+        emailTPPref.value = false;
+        emailTPPBMPref.value = true;
+        if (stpCookiePref.value) {
+          stpPref.value = false;
+        }
+        break;
+      case "never":
+        enabledPref.value = false;
+        pbmPref.value = false;
+        emailTPPref.value = false;
+        emailTPPBMPref.value = false;
+        if (stpCookiePref.value) {
+          stpPref.value = false;
+        }
+        break;
+    }
+  },
+
+  fingerprintingProtectionWritePrefs() {
+    let enabledPref = Preferences.get("privacy.fingerprintingProtection");
+    let pbmPref = Preferences.get("privacy.fingerprintingProtection.pbmode");
+    let fppMenu = document.getElementById("fingerprintingProtectionMenu");
+    let fppCheckbox = document.getElementById(
+      "contentBlockingFingerprintingProtectionCheckbox"
+    );
+
+    let value;
+    if (fppCheckbox.checked) {
+      if (fppMenu.value == "never") {
+        fppMenu.value = "private";
+      }
+      value = fppMenu.value;
+    } else {
+      fppMenu.value = "never";
+      value = "never";
+    }
+
+    fppMenu.disabled = !fppCheckbox.checked;
+
+    switch (value) {
+      case "always":
+        enabledPref.value = true;
+        pbmPref.value = true;
+        break;
+      case "private":
+        enabledPref.value = false;
+        pbmPref.value = true;
+        break;
+      case "never":
+        enabledPref.value = false;
+        pbmPref.value = false;
+        break;
+    }
+  },
+
+  toggleExpansion(e) {
+    let carat = e.target;
+    carat.classList.toggle("up");
+    carat.closest(".privacy-detailedoption").classList.toggle("expanded");
+    carat.setAttribute(
+      "aria-expanded",
+      carat.getAttribute("aria-expanded") === "false"
+    );
+  },
+
+  // HISTORY MODE
+
+  /**
+   * The list of preferences which affect the initial history mode settings.
+   * If the auto start private browsing mode pref is active, the initial
+   * history mode would be set to "Don't remember anything".
+   * If ALL of these preferences are set to the values that correspond
+   * to keeping some part of history, and the auto-start
+   * private browsing mode is not active, the initial history mode would be
+   * set to "Remember everything".
+   * Otherwise, the initial history mode would be set to "Custom".
+   *
+   * Extensions adding their own preferences can set values here if needed.
+   */
+  prefsForKeepingHistory: {
+    "places.history.enabled": true, // History is enabled
+    "browser.formfill.enable": true, // Form information is saved
+    "privacy.sanitize.sanitizeOnShutdown": false, // Private date is NOT cleared on shutdown
+  },
+
+  /**
+   * The list of control IDs which are dependent on the auto-start private
+   * browsing setting, such that in "Custom" mode they would be disabled if
+   * the auto-start private browsing checkbox is checked, and enabled otherwise.
+   *
+   * Extensions adding their own controls can append their IDs to this array if needed.
+   */
+  dependentControls: [
+    "rememberHistory",
+    "rememberForms",
+    "alwaysClear",
+    "clearDataSettings",
+  ],
+
+  /**
+   * Check whether preferences values are set to keep history
+   *
+   * @param aPrefs an array of pref names to check for
+   * @returns boolean true if all of the prefs are set to keep history,
+   *                  false otherwise
+   */
+  _checkHistoryValues(aPrefs) {
+    for (let pref of Object.keys(aPrefs)) {
+      if (Preferences.get(pref).value != aPrefs[pref]) {
+        return false;
+      }
+    }
+    return true;
+  },
+
+  /**
+   * Initialize the history mode menulist based on the privacy preferences
+   */
+  initializeHistoryMode() {
+    let mode;
+    let getVal = aPref => Preferences.get(aPref).value;
+
+    if (getVal("privacy.history.custom")) {
+      mode = "custom";
+    } else if (this._checkHistoryValues(this.prefsForKeepingHistory)) {
+      if (getVal("browser.privatebrowsing.autostart")) {
+        mode = "dontremember";
+      } else {
+        mode = "remember";
+      }
+    } else {
+      mode = "custom";
+    }
+
+    document.getElementById("historyMode").value = mode;
+  },
+
+  /**
+   * Update the selected pane based on the history mode menulist
+   */
+  updateHistoryModePane() {
+    let selectedIndex = -1;
+    switch (document.getElementById("historyMode").value) {
+      case "remember":
+        selectedIndex = 0;
+        break;
+      case "dontremember":
+        selectedIndex = 1;
+        break;
+      case "custom":
+        selectedIndex = 2;
+        break;
+    }
+    document.getElementById("historyPane").selectedIndex = selectedIndex;
+    Preferences.get("privacy.history.custom").value = selectedIndex == 2;
+  },
+
+  /**
+   * Update the private browsing auto-start pref and the history mode
+   * micro-management prefs based on the history mode menulist
+   */
+  updateHistoryModePrefs() {
+    let pref = Preferences.get("browser.privatebrowsing.autostart");
+    switch (document.getElementById("historyMode").value) {
+      case "remember":
+        if (pref.value) {
+          pref.value = false;
+        }
+
+        // select the remember history option if needed
+        Preferences.get("places.history.enabled").value = true;
+
+        // select the remember forms history option
+        Preferences.get("browser.formfill.enable").value = true;
+
+        // select the clear on close option
+        Preferences.get("privacy.sanitize.sanitizeOnShutdown").value = false;
+        break;
+      case "dontremember":
+        if (!pref.value) {
+          pref.value = true;
+        }
+        break;
+    }
+  },
+
+  /**
+   * Update the privacy micro-management controls based on the
+   * value of the private browsing auto-start preference.
+   */
+  updatePrivacyMicroControls() {
+    let clearDataSettings = document.getElementById("clearDataSettings");
+
+    if (document.getElementById("historyMode").value == "custom") {
+      let disabled = Preferences.get("browser.privatebrowsing.autostart").value;
+      this.dependentControls.forEach(aElement => {
+        let control = document.getElementById(aElement);
+        let preferenceId = control.getAttribute("preference");
+        if (!preferenceId) {
+          let dependentControlId = control.getAttribute("control");
+          if (dependentControlId) {
+            let dependentControl = document.getElementById(dependentControlId);
+            preferenceId = dependentControl.getAttribute("preference");
+          }
+        }
+
+        let preference = preferenceId ? Preferences.get(preferenceId) : {};
+        control.disabled = disabled || preference.locked;
+        if (control != clearDataSettings) {
+          this.ensurePrivacyMicroControlUncheckedWhenDisabled(control);
+        }
+      });
+
+      clearDataSettings.removeAttribute("hidden");
+
+      if (!disabled) {
+        // adjust the Settings button for sanitizeOnShutdown
+        this._updateSanitizeSettingsButton();
+      }
+    } else {
+      clearDataSettings.hidden = true;
+    }
+  },
+
+  ensurePrivacyMicroControlUncheckedWhenDisabled(el) {
+    if (Preferences.get("browser.privatebrowsing.autostart").value) {
+      // Set checked to false when called from updatePrivacyMicroControls
+      el.checked = false;
+      // return false for the onsyncfrompreference case:
+      return false;
+    }
+    return undefined; // tell preferencesBindings to assign the 'right' value.
+  },
+
+  // CLEAR PRIVATE DATA
+
+  /*
+   * Preferences:
+   *
+   * privacy.sanitize.sanitizeOnShutdown
+   * - true if the user's private data is cleared on startup according to the
+   *   Clear Private Data settings, false otherwise
+   */
+
+  /**
+   * Displays the Clear Private Data settings dialog.
+   */
+  showClearPrivateDataSettings() {
+    let dialogFile = useOldClearHistoryDialog
+      ? "chrome://browser/content/preferences/dialogs/sanitize.xhtml"
+      : "chrome://browser/content/sanitize_v2.xhtml";
+
+    gSubDialog.open(
+      dialogFile,
+      {
+        features: "resizable=no",
+      },
+      {
+        mode: "clearOnShutdown",
+      }
+    );
+  },
+
+  /**
+   * Displays a dialog from which individual parts of private data may be
+   * cleared.
+   */
+  clearPrivateDataNow(aClearEverything) {
+    var ts = Preferences.get("privacy.sanitize.timeSpan");
+    var timeSpanOrig = ts.value;
+
+    if (aClearEverything) {
+      ts.value = 0;
+    }
+
+    // Bug 1856418 We intend to remove the old dialog box
+    let dialogFile = useOldClearHistoryDialog
+      ? "chrome://browser/content/sanitize.xhtml"
+      : "chrome://browser/content/sanitize_v2.xhtml";
+
+    gSubDialog.open(dialogFile, {
+      features: "resizable=no",
+      closingCallback: () => {
+        // reset the timeSpan pref
+        if (aClearEverything) {
+          ts.value = timeSpanOrig;
+        }
+
+        Services.obs.notifyObservers(null, "clear-private-data");
+      },
+    });
+  },
+
+  /*
+   * On loading the page, assigns the state to the deleteOnClose checkbox that fits the pref selection
+   */
+  initDeleteOnCloseBox() {
+    let deleteOnCloseBox = document.getElementById("deleteOnClose");
+    deleteOnCloseBox.checked =
+      (Preferences.get("privacy.sanitize.sanitizeOnShutdown").value &&
+        Preferences.get("privacy.clearOnShutdown.cookies").value &&
+        Preferences.get("privacy.clearOnShutdown.cache").value &&
+        Preferences.get("privacy.clearOnShutdown.offlineApps").value) ||
+      Preferences.get("browser.privatebrowsing.autostart").value;
+  },
+
+  /*
+   * Keeps the state of the deleteOnClose checkbox in sync with the pref selection
+   */
+  syncSanitizationPrefsWithDeleteOnClose() {
+    let deleteOnCloseBox = document.getElementById("deleteOnClose");
+    let historyMode = Preferences.get("privacy.history.custom");
+    let sanitizeOnShutdownPref = Preferences.get(
+      "privacy.sanitize.sanitizeOnShutdown"
+    );
+    // ClearOnClose cleaning categories
+    let cookiePref = Preferences.get("privacy.clearOnShutdown.cookies");
+    let cachePref = Preferences.get("privacy.clearOnShutdown.cache");
+    let offlineAppsPref = Preferences.get(
+      "privacy.clearOnShutdown.offlineApps"
+    );
+
+    // Sync the cleaning prefs with the deleteOnClose box
+    deleteOnCloseBox.addEventListener("command", () => {
+      let { checked } = deleteOnCloseBox;
+      cookiePref.value = checked;
+      cachePref.value = checked;
+      offlineAppsPref.value = checked;
+      // Forget the current pref selection if sanitizeOnShutdown is disabled,
+      // to not over clear when it gets enabled by the sync mechanism
+      if (!sanitizeOnShutdownPref.value) {
+        this._resetCleaningPrefs();
+      }
+      // If no other cleaning category is selected, sanitizeOnShutdown gets synced with deleteOnClose
+      sanitizeOnShutdownPref.value =
+        this._isCustomCleaningPrefPresent() || checked;
+
+      // Update the view of the history settings
+      if (checked && !historyMode.value) {
+        historyMode.value = "custom";
+        this.initializeHistoryMode();
+        this.updateHistoryModePane();
+        this.updatePrivacyMicroControls();
+      }
+    });
+
+    cookiePref.on("change", this._onSanitizePrefChangeSyncClearOnClose);
+    cachePref.on("change", this._onSanitizePrefChangeSyncClearOnClose);
+    offlineAppsPref.on("change", this._onSanitizePrefChangeSyncClearOnClose);
+    sanitizeOnShutdownPref.on(
+      "change",
+      this._onSanitizePrefChangeSyncClearOnClose
+    );
+  },
+
+  /*
+   * Sync the deleteOnClose box to its cleaning prefs
+   */
+  _onSanitizePrefChangeSyncClearOnClose() {
+    let deleteOnCloseBox = document.getElementById("deleteOnClose");
+    deleteOnCloseBox.checked =
+      Preferences.get("privacy.clearOnShutdown.cookies").value &&
+      Preferences.get("privacy.clearOnShutdown.cache").value &&
+      Preferences.get("privacy.clearOnShutdown.offlineApps").value &&
+      Preferences.get("privacy.sanitize.sanitizeOnShutdown").value;
+  },
+
+  /*
+   * Unsets cleaning prefs that do not belong to DeleteOnClose
+   */
+  _resetCleaningPrefs() {
+    SANITIZE_ON_SHUTDOWN_PREFS_ONLY.forEach(
+      pref => (Preferences.get(pref).value = false)
+    );
+  },
+
+  /*
+   Checks if the user set cleaning prefs that do not belong to DeleteOnClose
+   */
+  _isCustomCleaningPrefPresent() {
+    return SANITIZE_ON_SHUTDOWN_PREFS_ONLY.some(
+      pref => Preferences.get(pref).value
+    );
+  },
+
+  /**
+   * Enables or disables the "Settings..." button depending
+   * on the privacy.sanitize.sanitizeOnShutdown preference value
+   */
+  _updateSanitizeSettingsButton() {
+    var settingsButton = document.getElementById("clearDataSettings");
+    var sanitizeOnShutdownPref = Preferences.get(
+      "privacy.sanitize.sanitizeOnShutdown"
+    );
+
+    settingsButton.disabled = !sanitizeOnShutdownPref.value;
+  },
+
+  toggleDoNotDisturbNotifications(event) {
+    AlertsServiceDND.manualDoNotDisturb = event.target.checked;
+  },
+
+  // PRIVATE BROWSING
+
+  /**
+   * Initialize the starting state for the auto-start private browsing mode pref reverter.
+   */
+  initAutoStartPrivateBrowsingReverter() {
+    // We determine the mode in initializeHistoryMode, which is guaranteed to have been
+    // called before now, so this is up-to-date.
+    let mode = document.getElementById("historyMode");
+    this._lastMode = mode.selectedIndex;
+    // The value of the autostart pref, on the other hand, is gotten from Preferences,
+    // which updates the DOM asynchronously, so we can't rely on the DOM. Get it directly
+    // from the prefs.
+    this._lastCheckState = Preferences.get(
+      "browser.privatebrowsing.autostart"
+    ).value;
+  },
+
+  _lastMode: null,
+  _lastCheckState: null,
+  async updateAutostart() {
+    let mode = document.getElementById("historyMode");
+    let autoStart = document.getElementById("privateBrowsingAutoStart");
+    let pref = Preferences.get("browser.privatebrowsing.autostart");
+    if (
+      (mode.value == "custom" && this._lastCheckState == autoStart.checked) ||
+      (mode.value == "remember" && !this._lastCheckState) ||
+      (mode.value == "dontremember" && this._lastCheckState)
+    ) {
+      // These are all no-op changes, so we don't need to prompt.
+      this._lastMode = mode.selectedIndex;
+      this._lastCheckState = autoStart.hasAttribute("checked");
+      return;
+    }
+
+    if (!this._shouldPromptForRestart) {
+      // We're performing a revert. Just let it happen.
+      return;
+    }
+
+    let buttonIndex = await confirmRestartPrompt(
+      autoStart.checked,
+      1,
+      true,
+      false
+    );
+    if (buttonIndex == CONFIRM_RESTART_PROMPT_RESTART_NOW) {
+      pref.value = autoStart.hasAttribute("checked");
+      Services.startup.quit(
+        Ci.nsIAppStartup.eAttemptQuit | Ci.nsIAppStartup.eRestart
+      );
+      return;
+    }
+
+    this._shouldPromptForRestart = false;
+
+    if (this._lastCheckState) {
+      autoStart.checked = "checked";
+    } else {
+      autoStart.removeAttribute("checked");
+    }
+    pref.value = autoStart.hasAttribute("checked");
+    mode.selectedIndex = this._lastMode;
+    mode.doCommand();
+
+    this._shouldPromptForRestart = true;
+  },
+
+  /**
+   * Displays fine-grained, per-site preferences for tracking protection.
+   */
+  showTrackingProtectionExceptions() {
+    let params = {
+      permissionType: "trackingprotection",
+      disableETPVisible: true,
+      prefilledHost: "",
+      hideStatusColumn: true,
+    };
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      undefined,
+      params
+    );
+  },
+
+  /**
+   * Displays the available block lists for tracking protection.
+   */
+  showBlockLists() {
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/blocklists.xhtml"
+    );
+  },
+
+  // COOKIES AND SITE DATA
+
+  /*
+   * Preferences:
+   *
+   * network.cookie.cookieBehavior
+   * - determines how the browser should handle cookies:
+   *     0   means enable all cookies
+   *     1   means reject all third party cookies
+   *     2   means disable all cookies
+   *     3   means reject third party cookies unless at least one is already set for the eTLD
+   *     4   means reject all trackers
+   *     5   means reject all trackers and partition third-party cookies
+   *         see netwerk/cookie/src/CookieService.cpp for details
+   */
+
+  /**
+   * Reads the network.cookie.cookieBehavior preference value and
+   * enables/disables the "blockCookiesMenu" menulist accordingly.
+   */
+  readBlockCookies() {
+    let bcControl = document.getElementById("blockCookiesMenu");
+    bcControl.disabled =
+      Services.cookies.getCookieBehavior(false) ==
+      Ci.nsICookieService.BEHAVIOR_ACCEPT;
+  },
+
+  /**
+   * Updates the "accept third party cookies" menu based on whether the
+   * "contentBlockingBlockCookiesCheckbox" checkbox is checked.
+   */
+  writeBlockCookies() {
+    let block = document.getElementById("contentBlockingBlockCookiesCheckbox");
+    let blockCookiesMenu = document.getElementById("blockCookiesMenu");
+
+    if (block.checked) {
+      // Automatically select 'third-party trackers' as the default.
+      blockCookiesMenu.selectedIndex = 0;
+      return this.writeBlockCookiesFrom();
+    }
+    return Ci.nsICookieService.BEHAVIOR_ACCEPT;
+  },
+
+  readBlockCookiesFrom() {
+    switch (Services.cookies.getCookieBehavior(false)) {
+      case Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN:
+        return "all-third-parties";
+      case Ci.nsICookieService.BEHAVIOR_REJECT:
+        return "always";
+      case Ci.nsICookieService.BEHAVIOR_LIMIT_FOREIGN:
+        return "unvisited";
+      case Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER:
+        return "trackers";
+      case BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN:
+        return "trackers-plus-isolate";
+      default:
+        return undefined;
+    }
+  },
+
+  writeBlockCookiesFrom() {
+    let block = document.getElementById("blockCookiesMenu").selectedItem;
+    switch (block.value) {
+      case "trackers":
+        return Ci.nsICookieService.BEHAVIOR_REJECT_TRACKER;
+      case "unvisited":
+        return Ci.nsICookieService.BEHAVIOR_LIMIT_FOREIGN;
+      case "always":
+        return Ci.nsICookieService.BEHAVIOR_REJECT;
+      case "all-third-parties":
+        return Ci.nsICookieService.BEHAVIOR_REJECT_FOREIGN;
+      case "trackers-plus-isolate":
+        return Ci.nsICookieService
+          .BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN;
+      default:
+        return undefined;
+    }
+  },
+
+  /**
+   * Discard the browsers of all tabs in all windows. Pinned tabs, as
+   * well as tabs for which discarding doesn't succeed (e.g. selected
+   * tabs, tabs with beforeunload listeners), are reloaded.
+   */
+  reloadAllOtherTabs() {
+    let ourTab = BrowserWindowTracker.getTopWindow().gBrowser.selectedTab;
+    BrowserWindowTracker.orderedWindows.forEach(win => {
+      let otherGBrowser = win.gBrowser;
+      for (let tab of otherGBrowser.tabs) {
+        if (tab == ourTab) {
+          // Don't reload our preferences tab.
+          continue;
+        }
+
+        if (tab.pinned || tab.selected) {
+          otherGBrowser.reloadTab(tab);
+        } else {
+          otherGBrowser.discardBrowser(tab);
+        }
+      }
+    });
+
+    for (let notification of document.querySelectorAll(".reload-tabs")) {
+      notification.hidden = true;
+    }
+  },
+
+  /**
+   * If there are more tabs than just the preferences tab, show a warning to the user that
+   * they need to reload their tabs to apply the setting.
+   */
+  maybeNotifyUserToReload() {
+    let shouldShow = false;
+    if (window.BrowserWindowTracker.orderedWindows.length > 1) {
+      shouldShow = true;
+    } else {
+      let tabbrowser = window.BrowserWindowTracker.getTopWindow().gBrowser;
+      if (tabbrowser.tabs.length > 1) {
+        shouldShow = true;
+      }
+    }
+    if (shouldShow) {
+      for (let notification of document.querySelectorAll(".reload-tabs")) {
+        notification.hidden = false;
+      }
+    }
+  },
+
+  /**
+   * Displays fine-grained, per-site preferences for cookies.
+   */
+  showCookieExceptions() {
+    var params = {
+      blockVisible: true,
+      sessionVisible: true,
+      allowVisible: true,
+      prefilledHost: "",
+      permissionType: "cookie",
+    };
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      undefined,
+      params
+    );
+  },
+
+  /**
+   * Displays per-site preferences for HTTPS-Only Mode exceptions.
+   */
+  showHttpsOnlyModeExceptions() {
+    var params = {
+      blockVisible: false,
+      sessionVisible: true,
+      allowVisible: false,
+      prefilledHost: "",
+      permissionType: "https-only-load-insecure",
+      forcedHTTP: true,
+    };
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      undefined,
+      params
+    );
+  },
+
+  showDoHExceptions() {
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/dohExceptions.xhtml",
+      undefined
+    );
+  },
+
+  showSiteDataSettings() {
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/siteDataSettings.xhtml"
+    );
+  },
+
+  toggleSiteData(shouldShow) {
+    let clearButton = document.getElementById("clearSiteDataButton");
+    let settingsButton = document.getElementById("siteDataSettings");
+    clearButton.disabled = !shouldShow;
+    settingsButton.disabled = !shouldShow;
+  },
+
+  showSiteDataLoading() {
+    let totalSiteDataSizeLabel = document.getElementById("totalSiteDataSize");
+    document.l10n.setAttributes(
+      totalSiteDataSizeLabel,
+      "sitedata-total-size-calculating"
+    );
+  },
+
+  updateTotalDataSizeLabel(siteDataUsage) {
+    SiteDataManager.getCacheSize().then(function (cacheUsage) {
+      let totalSiteDataSizeLabel = document.getElementById("totalSiteDataSize");
+      let totalUsage = siteDataUsage + cacheUsage;
+      let [value, unit] = DownloadUtils.convertByteUnits(totalUsage);
+      document.l10n.setAttributes(
+        totalSiteDataSizeLabel,
+        "sitedata-total-size",
+        {
+          value,
+          unit,
+        }
+      );
+    });
+  },
+
+  clearSiteData() {
+    // We have to use the full path name to avoid getting errors in
+    // browser/base/content/test/static/browser_all_files_referenced.js
+    let dialogFile = useOldClearHistoryDialog
+      ? "chrome://browser/content/preferences/dialogs/clearSiteData.xhtml"
+      : "chrome://browser/content/sanitize_v2.xhtml";
+
+    gSubDialog.open(
+      dialogFile,
+      {
+        features: "resizable=no",
+      },
+      {
+        mode: "clearSiteData",
+      }
+    );
+  },
+
+  /**
+   * Initializes the cookie banner handling subgroup on the privacy pane.
+   *
+   * This UI is shown if the "cookiebanners.ui.desktop.enabled" pref is true.
+   *
+   * The cookie banner handling checkbox reflects the cookie banner feature
+   * state. It is enabled when the service enabled via the
+   * cookiebanners.service.mode pref. If detection-only mode is enabled the
+   * checkbox is unchecked, since in this mode no banners are handled. It is
+   * only used for detection for banners which means we may prompt the user to
+   * enable the feature via other UI surfaces such as the onboarding doorhanger.
+   *
+   * If the user checks the checkbox, the pref value is set to
+   * nsICookieBannerService.MODE_REJECT_OR_ACCEPT.
+   *
+   * If the user unchecks the checkbox, the mode pref value is set to
+   * nsICookieBannerService.MODE_DISABLED.
+   *
+   * Advanced users can choose other int-valued modes via about:config.
+   */
+  initCookieBannerHandling() {
+    setSyncFromPrefListener("handleCookieBanners", () =>
+      this.readCookieBannerMode()
+    );
+    setSyncToPrefListener("handleCookieBanners", () =>
+      this.writeCookieBannerMode()
+    );
+
+    let preference = Preferences.get("cookiebanners.ui.desktop.enabled");
+    preference.on("change", () => this.updateCookieBannerHandlingVisibility());
+
+    this.updateCookieBannerHandlingVisibility();
+  },
+
+  /**
+   * Reads the cookiebanners.service.mode.privateBrowsing pref,
+   * interpreting the multiple modes as a true/false value
+   */
+  readCookieBannerMode() {
+    return (
+      Preferences.get("cookiebanners.service.mode.privateBrowsing").value !=
+      Ci.nsICookieBannerService.MODE_DISABLED
+    );
+  },
+
+  /**
+   * Translates user clicks on the cookie banner handling checkbox to the
+   * corresponding integer-valued cookie banner mode preference.
+   */
+  writeCookieBannerMode() {
+    let checkbox = document.getElementById("handleCookieBanners");
+    if (!checkbox.checked) {
+      /* because we removed UI control for the non-PBM pref, disabling it here
+         provides an off-ramp for profiles where it had previously been enabled from the UI */
+      Services.prefs.setIntPref(
+        "cookiebanners.service.mode",
+        Ci.nsICookieBannerService.MODE_DISABLED
+      );
+      return Ci.nsICookieBannerService.MODE_DISABLED;
+    }
+    return Ci.nsICookieBannerService.MODE_REJECT;
+  },
+
+  /**
+   * Shows or hides the cookie banner handling section based on the value of
+   * the "cookiebanners.ui.desktop.enabled" pref.
+   */
+  updateCookieBannerHandlingVisibility() {
+    let groupbox = document.getElementById("cookieBannerHandlingGroup");
+    let isEnabled = Preferences.get("cookiebanners.ui.desktop.enabled").value;
+
+    // Because the top-level pane showing code unsets the hidden attribute, we
+    // manually hide the section when cookie banner handling is preffed off.
+    if (isEnabled) {
+      groupbox.removeAttribute("style");
+    } else {
+      groupbox.setAttribute("style", "display: none !important");
+    }
+  },
+
+  /**
+   * Updates the visibility of the Firefox Suggest Privacy Container
+   * based on the user's Quick Suggest settings.
+   *
+   * @param {boolean} [onInit]
+   *   Pass true when calling this when initializing the pane.
+   */
+  _updateFirefoxSuggestToggle(onInit = false) {
+    let container = document.getElementById("firefoxSuggestPrivacyContainer");
+
+    if (UrlbarPrefs.get("quickSuggestEnabled")) {
+      container.removeAttribute("hidden");
+    } else if (!onInit) {
+      container.setAttribute("hidden", "true");
+    }
+  },
+
+  // GEOLOCATION
+
+  /**
+   * Displays the location exceptions dialog where specific site location
+   * preferences can be set.
+   */
+  showLocationExceptions() {
+    let params = { permissionType: "geo" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // XR
+
+  /**
+   * Displays the XR exceptions dialog where specific site XR
+   * preferences can be set.
+   */
+  showXRExceptions() {
+    let params = { permissionType: "xr" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // CAMERA
+
+  /**
+   * Displays the camera exceptions dialog where specific site camera
+   * preferences can be set.
+   */
+  showCameraExceptions() {
+    let params = { permissionType: "camera" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // MICROPHONE
+
+  /**
+   * Displays the microphone exceptions dialog where specific site microphone
+   * preferences can be set.
+   */
+  showMicrophoneExceptions() {
+    let params = { permissionType: "microphone" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // SPEAKER
+
+  /**
+   * Displays the speaker exceptions dialog where specific site speaker
+   * preferences can be set.
+   */
+  showSpeakerExceptions() {
+    let params = { permissionType: "speaker" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // NOTIFICATIONS
+
+  /**
+   * Displays the notifications exceptions dialog where specific site notification
+   * preferences can be set.
+   */
+  showNotificationExceptions() {
+    let params = { permissionType: "desktop-notification" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // MEDIA
+
+  showAutoplayMediaExceptions() {
+    var params = { permissionType: "autoplay-media" };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/sitePermissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // POP-UPS
+
+  /**
+   * Displays the popup exceptions dialog where specific site popup preferences
+   * can be set.
+   */
+  showPopupExceptions() {
+    var params = {
+      blockVisible: false,
+      sessionVisible: false,
+      allowVisible: true,
+      prefilledHost: "",
+      permissionType: "popup",
+    };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      { features: "resizable=yes" },
+      params
+    );
+  },
+
+  // UTILITY FUNCTIONS
+
+  /**
+   * Utility function to enable/disable the button specified by aButtonID based
+   * on the value of the Boolean preference specified by aPreferenceID.
+   */
+  updateButtons(aButtonID, aPreferenceID) {
+    var button = document.getElementById(aButtonID);
+    var preference = Preferences.get(aPreferenceID);
+    button.disabled = !preference.value || preference.locked;
+    return undefined;
+  },
+
+  // BEGIN UI CODE
+
+  /*
+   * Preferences:
+   *
+   * dom.disable_open_during_load
+   * - true if popups are blocked by default, false otherwise
+   */
+
+  // POP-UPS
+
+  /**
+   * Displays a dialog in which the user can view and modify the list of sites
+   * where passwords are never saved.
+   */
+  showPasswordExceptions() {
+    var params = {
+      blockVisible: true,
+      sessionVisible: false,
+      allowVisible: false,
+      hideStatusColumn: true,
+      prefilledHost: "",
+      permissionType: "login-saving",
+    };
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      undefined,
+      params
+    );
+  },
+
+  /**
+   * Initializes master password UI: the "use master password" checkbox, selects
+   * the master password button to show, and enables/disables it as necessary.
+   * The master password is controlled by various bits of NSS functionality, so
+   * the UI for it can't be controlled by the normal preference bindings.
+   */
+  _initMasterPasswordUI() {
+    var noMP = !LoginHelper.isPrimaryPasswordSet();
+
+    var button = document.getElementById("changeMasterPassword");
+    button.disabled = noMP;
+
+    var checkbox = document.getElementById("useMasterPassword");
+    checkbox.checked = !noMP;
+    checkbox.disabled =
+      (noMP && !Services.policies.isAllowed("createMasterPassword")) ||
+      (!noMP && !Services.policies.isAllowed("removeMasterPassword"));
+  },
+
+  /**
+   * Enables/disables the master password button depending on the state of the
+   * "use master password" checkbox, and prompts for master password removal if
+   * one is set.
+   */
+  async updateMasterPasswordButton() {
+    var checkbox = document.getElementById("useMasterPassword");
+    var button = document.getElementById("changeMasterPassword");
+    button.disabled = !checkbox.checked;
+
+    // unchecking the checkbox should try to immediately remove the master
+    // password, because it's impossible to non-destructively remove the master
+    // password used to encrypt all the passwords without providing it (by
+    // design), and it would be extremely odd to pop up that dialog when the
+    // user closes the prefwindow and saves his settings
+    if (!checkbox.checked) {
+      await this._removeMasterPassword();
+    } else {
+      await this.changeMasterPassword();
+    }
+
+    this._initMasterPasswordUI();
+  },
+
+  /**
+   * Displays the "remove master password" dialog to allow the user to remove
+   * the current master password.  When the dialog is dismissed, master password
+   * UI is automatically updated.
+   */
+  async _removeMasterPassword() {
+    var secmodDB = Cc["@mozilla.org/security/pkcs11moduledb;1"].getService(
+      Ci.nsIPKCS11ModuleDB
+    );
+    if (secmodDB.isFIPSEnabled) {
+      let title = document.getElementById("fips-title").textContent;
+      let desc = document.getElementById("fips-desc").textContent;
+      Services.prompt.alert(window, title, desc);
+      this._initMasterPasswordUI();
+    } else {
+      gSubDialog.open("chrome://mozapps/content/preferences/removemp.xhtml", {
+        closingCallback: this._initMasterPasswordUI.bind(this),
+      });
+    }
+  },
+
+  /**
+   * Displays a dialog in which the primary password may be changed.
+   */
+  async changeMasterPassword() {
+    // Require OS authentication before the user can set a Primary Password.
+    // OS reauthenticate functionality is not available on Linux yet (bug 1527745)
+    if (
+      !LoginHelper.isPrimaryPasswordSet() &&
+      OS_AUTH_ENABLED &&
+      OSKeyStore.canReauth()
+    ) {
+      // Uses primary-password-os-auth-dialog-message-win and
+      // primary-password-os-auth-dialog-message-macosx via concatenation:
+      let messageId =
+        "primary-password-os-auth-dialog-message-" + AppConstants.platform;
+      let [messageText, captionText] = await document.l10n.formatMessages([
+        {
+          id: messageId,
+        },
+        {
+          id: "master-password-os-auth-dialog-caption",
+        },
+      ]);
+      let win = Services.wm.getMostRecentBrowserWindow();
+      let loggedIn = await OSKeyStore.ensureLoggedIn(
+        messageText.value,
+        captionText.value,
+        win,
+        false
+      );
+      if (!loggedIn.authenticated) {
+        return;
+      }
+    }
+
+    gSubDialog.open("chrome://mozapps/content/preferences/changemp.xhtml", {
+      features: "resizable=no",
+      closingCallback: this._initMasterPasswordUI.bind(this),
+    });
+  },
+
+  /**
+   * Set up the initial state for the GPC/DNT UI.
+   * The GPC part should only appear if the functionality is
+   * enabled.
+   */
+  _initGlobalPrivacyControlUI() {
+    let gpcEnabledPrefValue = Services.prefs.getBoolPref(
+      "privacy.globalprivacycontrol.functionality.enabled",
+      false
+    );
+    document.getElementById("globalPrivacyControlBox").hidden =
+      !gpcEnabledPrefValue;
+    document.getElementById("doNotTrackBox").hidden = !gpcEnabledPrefValue;
+    document.getElementById("legacyDoNotTrackBox").hidden = gpcEnabledPrefValue;
+  },
+
+  /**
+   * Set up the initial state for the password generation UI.
+   * It will be hidden unless the .available pref is true
+   */
+  _initPasswordGenerationUI() {
+    // we don't watch the .available pref for runtime changes
+    let prefValue = Services.prefs.getBoolPref(
+      PREF_PASSWORD_GENERATION_AVAILABLE,
+      false
+    );
+    document.getElementById("generatePasswordsBox").hidden = !prefValue;
+  },
+
+  toggleRelayIntegration() {
+    const checkbox = document.getElementById("relayIntegration");
+    if (checkbox.checked) {
+      FirefoxRelay.markAsAvailable();
+      FirefoxRelayTelemetry.recordRelayPrefEvent("enabled");
+    } else {
+      FirefoxRelay.markAsDisabled();
+      FirefoxRelayTelemetry.recordRelayPrefEvent("disabled");
+    }
+  },
+
+  _updateRelayIntegrationUI() {
+    document.getElementById("relayIntegrationBox").hidden =
+      !FirefoxRelay.isAvailable;
+    document.getElementById("relayIntegration").checked =
+      FirefoxRelay.isAvailable && !FirefoxRelay.isDisabled;
+  },
+
+  _initRelayIntegrationUI() {
+    document
+      .getElementById("relayIntegrationLearnMoreLink")
+      .setAttribute("href", FirefoxRelay.learnMoreUrl);
+
+    setEventListener(
+      "relayIntegration",
+      "command",
+      gPrivacyPane.toggleRelayIntegration.bind(gPrivacyPane)
+    );
+    Preferences.get("signon.firefoxRelay.feature").on(
+      "change",
+      gPrivacyPane._updateRelayIntegrationUI.bind(gPrivacyPane)
+    );
+
+    this._updateRelayIntegrationUI();
+  },
+
+  /**
+   * Shows the sites where the user has saved passwords and the associated login
+   * information.
+   */
+  showPasswords() {
+    let loginManager = window.windowGlobalChild.getActor("LoginManager");
+    loginManager.sendAsyncMessage("PasswordManager:OpenPreferences", {
+      entryPoint: "preferences",
+    });
+  },
+
+  /**
+   * Enables/disables dependent controls related to password saving
+   * When password saving is not enabled, we need to also disable the password generation checkbox
+   * The Exceptions button is used to configure sites where passwords are never saved.
+   */
+  readSavePasswords() {
+    var prefValue = Preferences.get("signon.rememberSignons").value;
+    document.getElementById("passwordExceptions").disabled = !prefValue;
+    document.getElementById("generatePasswords").disabled = !prefValue;
+    document.getElementById("passwordAutofillCheckbox").disabled = !prefValue;
+    document.getElementById("relayIntegration").disabled =
+      !prefValue || Services.prefs.prefIsLocked("signon.firefoxRelay.feature");
+    // don't override pref value in UI
+    return undefined;
+  },
+
+  /**
+   * Initalizes pref listeners for the password manager.
+   *
+   * This ensures that the user is always notified if an extension is controlling the password manager.
+   */
+  initListenersForExtensionControllingPasswordManager() {
+    this._passwordManagerCheckbox = document.getElementById("savePasswords");
+    this._disableExtensionButton = document.getElementById(
+      "disablePasswordManagerExtension"
+    );
+
+    this._disableExtensionButton.addEventListener(
+      "command",
+      makeDisableControllingExtension(
+        PREF_SETTING_TYPE,
+        PASSWORD_MANAGER_PREF_ID
+      )
+    );
+
+    initListenersForPrefChange(
+      PREF_SETTING_TYPE,
+      PASSWORD_MANAGER_PREF_ID,
+      this._passwordManagerCheckbox
+    );
+  },
+
+  /**
+   * Enables/disables the add-ons Exceptions button depending on whether
+   * or not add-on installation warnings are displayed.
+   */
+  readWarnAddonInstall() {
+    var warn = Preferences.get("xpinstall.whitelist.required");
+    var exceptions = document.getElementById("addonExceptions");
+
+    exceptions.disabled = !warn.value || warn.locked;
+
+    // don't override the preference value
+    return undefined;
+  },
+
+  _initSafeBrowsing() {
+    let enableSafeBrowsing = document.getElementById("enableSafeBrowsing");
+    let blockDownloads = document.getElementById("blockDownloads");
+    let blockUncommonUnwanted = document.getElementById(
+      "blockUncommonUnwanted"
+    );
+
+    let safeBrowsingPhishingPref = Preferences.get(
+      "browser.safebrowsing.phishing.enabled"
+    );
+    let safeBrowsingMalwarePref = Preferences.get(
+      "browser.safebrowsing.malware.enabled"
+    );
+
+    let blockDownloadsPref = Preferences.get(
+      "browser.safebrowsing.downloads.enabled"
+    );
+    let malwareTable = Preferences.get("urlclassifier.malwareTable");
+
+    let blockUnwantedPref = Preferences.get(
+      "browser.safebrowsing.downloads.remote.block_potentially_unwanted"
+    );
+    let blockUncommonPref = Preferences.get(
+      "browser.safebrowsing.downloads.remote.block_uncommon"
+    );
+
+    enableSafeBrowsing.addEventListener("command", function () {
+      safeBrowsingPhishingPref.value = enableSafeBrowsing.checked;
+      safeBrowsingMalwarePref.value = enableSafeBrowsing.checked;
+
+      blockDownloads.disabled =
+        !enableSafeBrowsing.checked || blockDownloadsPref.locked;
+      blockUncommonUnwanted.disabled =
+        !blockDownloads.checked ||
+        !enableSafeBrowsing.checked ||
+        blockUnwantedPref.locked ||
+        blockUncommonPref.locked;
+    });
+
+    blockDownloads.addEventListener("command", function () {
+      blockDownloadsPref.value = blockDownloads.checked;
+      blockUncommonUnwanted.disabled =
+        !blockDownloads.checked ||
+        blockUnwantedPref.locked ||
+        blockUncommonPref.locked;
+    });
+
+    blockUncommonUnwanted.addEventListener("command", function () {
+      blockUnwantedPref.value = blockUncommonUnwanted.checked;
+      blockUncommonPref.value = blockUncommonUnwanted.checked;
+
+      let malware = malwareTable.value
+        .split(",")
+        .filter(
+          x =>
+            x !== "goog-unwanted-proto" &&
+            x !== "goog-unwanted-shavar" &&
+            x !== "moztest-unwanted-simple"
+        );
+
+      if (blockUncommonUnwanted.checked) {
+        if (malware.includes("goog-malware-shavar")) {
+          malware.push("goog-unwanted-shavar");
+        } else {
+          malware.push("goog-unwanted-proto");
+        }
+
+        malware.push("moztest-unwanted-simple");
+      }
+
+      // sort alphabetically to keep the pref consistent
+      malware.sort();
+
+      malwareTable.value = malware.join(",");
+
+      // Force an update after changing the malware table.
+      listManager.forceUpdates(malwareTable.value);
+    });
+
+    // set initial values
+
+    enableSafeBrowsing.checked =
+      safeBrowsingPhishingPref.value && safeBrowsingMalwarePref.value;
+    if (!enableSafeBrowsing.checked) {
+      blockDownloads.setAttribute("disabled", "true");
+      blockUncommonUnwanted.setAttribute("disabled", "true");
+    }
+
+    blockDownloads.checked = blockDownloadsPref.value;
+    if (!blockDownloadsPref.value) {
+      blockUncommonUnwanted.setAttribute("disabled", "true");
+    }
+    blockUncommonUnwanted.checked =
+      blockUnwantedPref.value && blockUncommonPref.value;
+
+    if (safeBrowsingPhishingPref.locked || safeBrowsingMalwarePref.locked) {
+      enableSafeBrowsing.disabled = true;
+    }
+    if (blockDownloadsPref.locked) {
+      blockDownloads.disabled = true;
+    }
+    if (blockUnwantedPref.locked || blockUncommonPref.locked) {
+      blockUncommonUnwanted.disabled = true;
+    }
+  },
+
+  /**
+   * Displays the exceptions lists for add-on installation warnings.
+   */
+  showAddonExceptions() {
+    var params = this._addonParams;
+
+    gSubDialog.open(
+      "chrome://browser/content/preferences/dialogs/permissions.xhtml",
+      undefined,
+      params
+    );
+  },
+
+  /**
+   * Parameters for the add-on install permissions dialog.
+   */
+  _addonParams: {
+    blockVisible: false,
+    sessionVisible: false,
+    allowVisible: true,
+    prefilledHost: "",
+    permissionType: "install",
+  },
+
+  /**
+   * readEnableOCSP is used by the preferences UI to determine whether or not
+   * the checkbox for OCSP fetching should be checked (it returns true if it
+   * should be checked and false otherwise). The about:config preference
+   * "security.OCSP.enabled" is an integer rather than a boolean, so it can't be
+   * directly mapped from {true,false} to {checked,unchecked}. The possible
+   * values for "security.OCSP.enabled" are:
+   * 0: fetching is disabled
+   * 1: fetch for all certificates
+   * 2: fetch only for EV certificates
+   * Hence, if "security.OCSP.enabled" is non-zero, the checkbox should be
+   * checked. Otherwise, it should be unchecked.
+   */
+  readEnableOCSP() {
+    var preference = Preferences.get("security.OCSP.enabled");
+    // This is the case if the preference is the default value.
+    if (preference.value === undefined) {
+      return true;
+    }
+    return preference.value != 0;
+  },
+
+  /**
+   * writeEnableOCSP is used by the preferences UI to map the checked/unchecked
+   * state of the OCSP fetching checkbox to the value that the preference
+   * "security.OCSP.enabled" should be set to (it returns that value). See the
+   * readEnableOCSP documentation for more background. We unfortunately don't
+   * have enough information to map from {true,false} to all possible values for
+   * "security.OCSP.enabled", but a reasonable alternative is to map from
+   * {true,false} to {<the default value>,0}. That is, if the box is checked,
+   * "security.OCSP.enabled" will be set to whatever default it should be, given
+   * the platform and channel. If the box is unchecked, the preference will be
+   * set to 0. Obviously this won't work if the default is 0, so we will have to
+   * revisit this if we ever set it to 0.
+   */
+  writeEnableOCSP() {
+    var checkbox = document.getElementById("enableOCSP");
+    var defaults = Services.prefs.getDefaultBranch(null);
+    var defaultValue = defaults.getIntPref("security.OCSP.enabled");
+    return checkbox.checked ? defaultValue : 0;
+  },
+
+  /**
+   * Displays the user's certificates and associated options.
+   */
+  showCertificates() {
+    gSubDialog.open("chrome://pippki/content/certManager.xhtml");
+  },
+
+  /**
+   * Displays a dialog from which the user can manage his security devices.
+   */
+  showSecurityDevices() {
+    gSubDialog.open("chrome://pippki/content/device_manager.xhtml");
+  },
+
+  /**
+   * Displays the learn more health report page when a user opts out of data collection.
+   */
+  showDataDeletion() {
+    let url =
+      Services.urlFormatter.formatURLPref("app.support.baseURL") +
+      "telemetry-clientid";
+    window.open(url, "_blank");
+  },
+
+  initDataCollection() {
+    if (
+      !AppConstants.MOZ_DATA_REPORTING &&
+      !NimbusFeatures.majorRelease2022.getVariable(
+        "feltPrivacyShowPreferencesSection"
+      )
+    ) {
+      // Nothing to control in the data collection section, remove it.
+      document.getElementById("dataCollectionCategory").remove();
+      document.getElementById("dataCollectionGroup").remove();
+      return;
+    }
+
+    this._setupLearnMoreLink(
+      "toolkit.datacollection.infoURL",
+      "dataCollectionPrivacyNotice"
+    );
+    this.initPrivacySegmentation();
+  },
+
+  initSubmitCrashes() {
+    this._setupLearnMoreLink(
+      "toolkit.crashreporter.infoURL",
+      "crashReporterLearnMore"
+    );
+    setEventListener("crashReporterLabel", "click", function (event) {
+      if (event.target.localName == "a") {
+        return;
+      }
+      const checkboxId = event.target.getAttribute("for");
+      document.getElementById(checkboxId).click();
+    });
+  },
+
+  initPrivacySegmentation() {
+    // Section visibility
+    let section = document.getElementById("privacySegmentationSection");
+    let updatePrivacySegmentationSectionVisibilityState = () => {
+      section.hidden = !NimbusFeatures.majorRelease2022.getVariable(
+        "feltPrivacyShowPreferencesSection"
+      );
+    };
+
+    NimbusFeatures.majorRelease2022.onUpdate(
+      updatePrivacySegmentationSectionVisibilityState
+    );
+    window.addEventListener("unload", () => {
+      NimbusFeatures.majorRelease2022.offUpdate(
+        updatePrivacySegmentationSectionVisibilityState
+      );
+    });
+
+    updatePrivacySegmentationSectionVisibilityState();
+  },
+
+  /**
+   * Set up or hide the Learn More links for various data collection options
+   */
+  _setupLearnMoreLink(pref, element) {
+    // set up the Learn More link with the correct URL
+    let url = Services.urlFormatter.formatURLPref(pref);
+    let el = document.getElementById(element);
+
+    if (url) {
+      el.setAttribute("href", url);
+    } else {
+      el.hidden = true;
+    }
+  },
+
+  /**
+   * Initialize the health report service reference and checkbox.
+   */
+  initSubmitHealthReport() {
+    this._setupLearnMoreLink(
+      "datareporting.healthreport.infoURL",
+      "FHRLearnMore"
+    );
+
+    let checkbox = document.getElementById("submitHealthReportBox");
+
+    // Telemetry is only sending data if MOZ_TELEMETRY_REPORTING is defined.
+    // We still want to display the preferences panel if that's not the case, but
+    // we want it to be disabled and unchecked.
+    if (
+      Services.prefs.prefIsLocked(PREF_UPLOAD_ENABLED) ||
+      !AppConstants.MOZ_TELEMETRY_REPORTING
+    ) {
+      checkbox.setAttribute("disabled", "true");
+      return;
+    }
+
+    checkbox.checked =
+      Services.prefs.getBoolPref(PREF_UPLOAD_ENABLED) &&
+      AppConstants.MOZ_TELEMETRY_REPORTING;
+  },
+
+  /**
+   * Update the health report preference with state from checkbox.
+   */
+  updateSubmitHealthReport() {
+    let checkbox = document.getElementById("submitHealthReportBox");
+    let telemetryContainer = document.getElementById("telemetry-container");
+
+    Services.prefs.setBoolPref(PREF_UPLOAD_ENABLED, checkbox.checked);
+    telemetryContainer.hidden = checkbox.checked;
+  },
+
+  /**
+   * Initialize the opt-out-study preference checkbox into about:preferences and
+   * handles events coming from the UI for it.
+   */
+  initOptOutStudyCheckbox(doc) {
+    // The checkbox should be disabled if any of the below are true. This
+    // prevents the user from changing the value in the box.
+    //
+    // * the policy forbids shield
+    // * Normandy is disabled
+    //
+    // The checkbox should match the value of the preference only if all of
+    // these are true. Otherwise, the checkbox should remain unchecked. This
+    // is because in these situations, Shield studies are always disabled, and
+    // so showing a checkbox would be confusing.
+    //
+    // * the policy allows Shield
+    // * Normandy is enabled
+
+    const allowedByPolicy = Services.policies.isAllowed("Shield");
+    const checkbox = document.getElementById("optOutStudiesEnabled");
+
+    if (
+      allowedByPolicy &&
+      Services.prefs.getBoolPref(PREF_NORMANDY_ENABLED, false)
+    ) {
+      if (Services.prefs.getBoolPref(PREF_OPT_OUT_STUDIES_ENABLED, false)) {
+        checkbox.setAttribute("checked", "true");
+      } else {
+        checkbox.removeAttribute("checked");
+      }
+      checkbox.setAttribute("preference", PREF_OPT_OUT_STUDIES_ENABLED);
+      checkbox.removeAttribute("disabled");
+    } else {
+      checkbox.removeAttribute("preference");
+      checkbox.removeAttribute("checked");
+      checkbox.setAttribute("disabled", "true");
+    }
+  },
+
+  initAddonRecommendationsCheckbox() {
+    // Setup the checkbox.
+    dataCollectionCheckboxHandler({
+      checkbox: document.getElementById("addonRecommendationEnabled"),
+      pref: PREF_ADDON_RECOMMENDATIONS_ENABLED,
+    });
+  },
+
+  observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "sitedatamanager:updating-sites":
+        // While updating, we want to disable this section and display loading message until updated
+        this.toggleSiteData(false);
+        this.showSiteDataLoading();
+        break;
+
+      case "sitedatamanager:sites-updated":
+        this.toggleSiteData(true);
+        SiteDataManager.getTotalUsage().then(
+          this.updateTotalDataSizeLabel.bind(this)
+        );
+        break;
+      case "network:trr-uri-changed":
+      case "network:trr-mode-changed":
+      case "network:trr-confirmation":
+        gPrivacyPane.updateDoHStatus();
+        break;
+    }
+  },
+};