Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 2962 insertions, 0 deletions

diff --git a/comm/mail/components/preferences/general.js b/comm/mail/components/preferences/general.js
new file mode 100644
index 0000000000..96e8aaad2d
--- /dev/null
+++ b/comm/mail/components/preferences/general.js
@@ -0,0 +1,2962 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/* import-globals-from ../../base/content/aboutDialog-appUpdater.js */
+/* import-globals-from ../../../../toolkit/mozapps/preferences/fontbuilder.js */
+/* import-globals-from preferences.js */
+
+// ------------------------------
+// Constants & Enumeration Values
+
+var { DownloadUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/DownloadUtils.sys.mjs"
+);
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+var { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+var { UpdateUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/UpdateUtils.sys.mjs"
+);
+var { TagUtils } = ChromeUtils.import("resource:///modules/TagUtils.jsm");
+
+XPCOMUtils.defineLazyServiceGetters(this, {
+  gHandlerService: [
+    "@mozilla.org/uriloader/handler-service;1",
+    "nsIHandlerService",
+  ],
+  gMIMEService: ["@mozilla.org/mime;1", "nsIMIMEService"],
+});
+
+XPCOMUtils.defineLazyGetter(this, "gIsPackagedApp", () => {
+  return Services.sysinfo.getProperty("isPackagedApp");
+});
+
+const TYPE_PDF = "application/pdf";
+
+const PREF_PDFJS_DISABLED = "pdfjs.disabled";
+
+const AUTO_UPDATE_CHANGED_TOPIC = "auto-update-config-change";
+
+Preferences.addAll([
+  { id: "mail.pane_config.dynamic", type: "int" },
+  { id: "mailnews.reuse_message_window", type: "bool" },
+  { id: "mailnews.start_page.enabled", type: "bool" },
+  { id: "mailnews.start_page.url", type: "string" },
+  { id: "mail.biff.show_tray_icon", type: "bool" },
+  { id: "mail.biff.play_sound", type: "bool" },
+  { id: "mail.biff.play_sound.type", type: "int" },
+  { id: "mail.biff.play_sound.url", type: "string" },
+  { id: "mail.biff.use_system_alert", type: "bool" },
+  { id: "general.autoScroll", type: "bool" },
+  { id: "general.smoothScroll", type: "bool" },
+  { id: "widget.gtk.overlay-scrollbars.enabled", type: "bool", inverted: true },
+  { id: "mail.fixed_width_messages", type: "bool" },
+  { id: "mail.inline_attachments", type: "bool" },
+  { id: "mail.quoted_style", type: "int" },
+  { id: "mail.quoted_size", type: "int" },
+  { id: "mail.citation_color", type: "string" },
+  { id: "mail.display_glyph", type: "bool" },
+  { id: "font.language.group", type: "wstring" },
+  { id: "intl.regional_prefs.use_os_locales", type: "bool" },
+  { id: "mailnews.database.global.indexer.enabled", type: "bool" },
+  { id: "mailnews.labels.description.1", type: "wstring" },
+  { id: "mailnews.labels.color.1", type: "string" },
+  { id: "mailnews.labels.description.2", type: "wstring" },
+  { id: "mailnews.labels.color.2", type: "string" },
+  { id: "mailnews.labels.description.3", type: "wstring" },
+  { id: "mailnews.labels.color.3", type: "string" },
+  { id: "mailnews.labels.description.4", type: "wstring" },
+  { id: "mailnews.labels.color.4", type: "string" },
+  { id: "mailnews.labels.description.5", type: "wstring" },
+  { id: "mailnews.labels.color.5", type: "string" },
+  { id: "mail.showCondensedAddresses", type: "bool" },
+  { id: "mailnews.mark_message_read.auto", type: "bool" },
+  { id: "mailnews.mark_message_read.delay", type: "bool" },
+  { id: "mailnews.mark_message_read.delay.interval", type: "int" },
+  { id: "mail.openMessageBehavior", type: "int" },
+  { id: "mail.close_message_window.on_delete", type: "bool" },
+  { id: "mail.prompt_purge_threshhold", type: "bool" },
+  { id: "mail.purge.ask", type: "bool" },
+  { id: "mail.purge_threshhold_mb", type: "int" },
+  { id: "browser.cache.disk.capacity", type: "int" },
+  { id: "browser.cache.disk.smart_size.enabled", inverted: true, type: "bool" },
+  { id: "privacy.clearOnShutdown.cache", type: "bool" },
+  { id: "layers.acceleration.disabled", type: "bool", inverted: true },
+  { id: "searchintegration.enable", type: "bool" },
+  { id: "mail.tabs.drawInTitlebar", type: "bool" },
+  { id: "mail.tabs.autoHide", type: "bool" },
+]);
+if (AppConstants.platform == "win") {
+  Preferences.add({ id: "mail.minimizeToTray", type: "bool" });
+}
+if (AppConstants.platform != "macosx") {
+  Preferences.add({ id: "mail.biff.show_alert", type: "bool" });
+}
+
+var ICON_URL_APP = "";
+
+if (AppConstants.MOZ_WIDGET_GTK) {
+  ICON_URL_APP = "moz-icon://dummy.exe?size=16";
+} else {
+  ICON_URL_APP = "chrome://messenger/skin/preferences/application.png";
+}
+
+if (AppConstants.HAVE_SHELL_SERVICE) {
+  Preferences.addAll([
+    { id: "mail.shell.checkDefaultClient", type: "bool" },
+    { id: "pref.general.disable_button.default_mail", type: "bool" },
+  ]);
+}
+
+if (AppConstants.MOZ_UPDATER) {
+  Preferences.add({
+    id: "app.update.disable_button.showUpdateHistory",
+    type: "bool",
+  });
+  if (AppConstants.MOZ_MAINTENANCE_SERVICE) {
+    Preferences.add({ id: "app.update.service.enabled", type: "bool" });
+  }
+}
+
+var gGeneralPane = {
+  // The set of types the app knows how to handle. A map of HandlerInfoWrapper
+  // objects, indexed by type.
+  _handledTypes: new Map(),
+  // Map from a handlerInfoWrapper to the corresponding table HandlerRow.
+  _handlerRows: new Map(),
+  _handlerMenuId: 0,
+
+  // The list of types we can show, sorted by the sort column/direction.
+  // An array of HandlerInfoWrapper objects.  We build this list when we first
+  // load the data and then rebuild it when users change a pref that affects
+  // what types we can show or change the sort column/direction.
+  // Note: this isn't necessarily the list of types we *will* show; if the user
+  // provides a filter string, we'll only show the subset of types in this list
+  // that match that string.
+  _visibleTypes: [],
+
+  // Map whose keys are string descriptions and values are references to the
+  // first visible HandlerInfoWrapper that has this description. We use this
+  // to determine whether or not to annotate descriptions with their types to
+  // distinguish duplicate descriptions from each other.
+  _visibleDescriptions: new Map(),
+
+  // -----------------------------------
+  // Convenience & Performance Shortcuts
+
+  // These get defined by init().
+  _brandShortName: null,
+  _handlerTbody: null,
+  _filter: null,
+  _prefsBundle: null,
+  mPane: null,
+  mStartPageUrl: "",
+  mShellServiceWorking: false,
+  mTagListBox: null,
+  requestingLocales: null,
+
+  async init() {
+    function setEventListener(aId, aEventType, aCallback) {
+      document
+        .getElementById(aId)
+        .addEventListener(aEventType, aCallback.bind(gGeneralPane));
+    }
+
+    Preferences.addSyncFromPrefListener(
+      document.getElementById("saveWhere"),
+      () => gDownloadDirSection.onReadUseDownloadDir()
+    );
+
+    this.mPane = document.getElementById("paneGeneral");
+    this._prefsBundle = document.getElementById("bundlePreferences");
+    this._brandShortName = document
+      .getElementById("bundleBrand")
+      .getString("brandShortName");
+    this._handlerTbody = document.querySelector("#handlersTable > tbody");
+    this._filter = document.getElementById("filter");
+
+    this._handlerSort = { type: "type", descending: false };
+    this._handlerSortHeaders = document.querySelectorAll(
+      "#handlersTable > thead th[sort-type]"
+    );
+    for (let header of this._handlerSortHeaders) {
+      let button = header.querySelector("button");
+      button.addEventListener(
+        "click",
+        this.sort.bind(this, header.getAttribute("sort-type"))
+      );
+    }
+
+    this.updateStartPage();
+    this.updatePlaySound(
+      !Preferences.get("mail.biff.play_sound").value,
+      Preferences.get("mail.biff.play_sound.url").value,
+      Preferences.get("mail.biff.play_sound.type").value
+    );
+    if (AppConstants.platform != "macosx") {
+      this.updateShowAlert();
+    }
+    this.updateWebSearch();
+
+    // Search integration -- check whether we should hide or disable integration
+    let hideSearchUI = false;
+    let disableSearchUI = false;
+    const { SearchIntegration } = ChromeUtils.import(
+      "resource:///modules/SearchIntegration.jsm"
+    );
+    if (SearchIntegration) {
+      if (SearchIntegration.osVersionTooLow) {
+        hideSearchUI = true;
+      } else if (SearchIntegration.osComponentsNotRunning) {
+        disableSearchUI = true;
+      }
+    } else {
+      hideSearchUI = true;
+    }
+
+    if (hideSearchUI) {
+      document.getElementById("searchIntegrationContainer").hidden = true;
+    } else if (disableSearchUI) {
+      let searchCheckbox = document.getElementById("searchIntegration");
+      searchCheckbox.checked = false;
+      Preferences.get("searchintegration.enable").disabled = true;
+    }
+
+    // If the shell service is not working, disable the "Check now" button
+    // and "perform check at startup" checkbox.
+    try {
+      Cc["@mozilla.org/mail/shell-service;1"].getService(Ci.nsIShellService);
+      this.mShellServiceWorking = true;
+    } catch (ex) {
+      // The elements may not exist if HAVE_SHELL_SERVICE is off.
+      if (document.getElementById("alwaysCheckDefault")) {
+        document.getElementById("alwaysCheckDefault").disabled = true;
+        document.getElementById("alwaysCheckDefault").checked = false;
+      }
+      if (document.getElementById("checkDefaultButton")) {
+        document.getElementById("checkDefaultButton").disabled = true;
+      }
+      this.mShellServiceWorking = false;
+    }
+    this._rebuildFonts();
+
+    var menulist = document.getElementById("defaultFont");
+    if (menulist.selectedIndex == -1) {
+      // Prepend menuitem with empty name and value.
+      let item = document.createXULElement("menuitem");
+      item.setAttribute("label", "");
+      item.setAttribute("value", "");
+      menulist.menupopup.insertBefore(
+        item,
+        menulist.menupopup.firstElementChild
+      );
+      menulist.selectedIndex = 0;
+    }
+
+    this.formatLocaleSetLabels();
+
+    if (Services.prefs.getBoolPref("intl.multilingual.enabled")) {
+      this.initPrimaryMessengerLanguageUI();
+    }
+
+    this.mTagListBox = document.getElementById("tagList");
+    this.buildTagList();
+    this.updateMarkAsReadOptions();
+
+    document.getElementById("citationmenu").value = Preferences.get(
+      "mail.citation_color"
+    ).value;
+
+    // By doing this in a timeout, we let the preferences dialog resize itself
+    // to an appropriate size before we add a bunch of items to the list.
+    // Otherwise, if there are many items, and the Applications prefpane
+    // is the one that gets displayed when the user first opens the dialog,
+    // the dialog might stretch too much in an attempt to fit them all in.
+    // XXX Shouldn't we perhaps just set a max-height on the richlistbox?
+    var _delayedPaneLoad = function (self) {
+      self._loadAppHandlerData();
+      self._rebuildVisibleTypes();
+      self._sortVisibleTypes();
+      self._rebuildView();
+
+      // Notify observers that the UI is now ready
+      Services.obs.notifyObservers(window, "app-handler-pane-loaded");
+    };
+    this.updateActualCacheSize();
+    this.updateCompactOptions();
+
+    // Default store type initialization.
+    let storeTypeElement = document.getElementById("storeTypeMenulist");
+    // set the menuitem to match the account
+    let defaultStoreID = Services.prefs.getCharPref(
+      "mail.serverDefaultStoreContractID"
+    );
+    let targetItem = storeTypeElement.getElementsByAttribute(
+      "value",
+      defaultStoreID
+    );
+    storeTypeElement.selectedItem = targetItem[0];
+    setTimeout(_delayedPaneLoad, 0, this);
+
+    if (AppConstants.MOZ_UPDATER) {
+      this.updateReadPrefs();
+      gAppUpdater = new appUpdater(); // eslint-disable-line no-global-assign
+      let updateDisabled =
+        Services.policies && !Services.policies.isAllowed("appUpdate");
+
+      if (gIsPackagedApp) {
+        // When we're running inside an app package, there's no point in
+        // displaying any update content here, and it would get confusing if we
+        // did, because our updater is not enabled.
+        // We can't rely on the hidden attribute for the toplevel elements,
+        // because of the pane hiding/showing code interfering.
+        document
+          .getElementById("updatesCategory")
+          .setAttribute("style", "display: none !important");
+        document
+          .getElementById("updateApp")
+          .setAttribute("style", "display: none !important");
+      } else if (updateDisabled || UpdateUtils.appUpdateAutoSettingIsLocked()) {
+        document.getElementById("updateAllowDescription").hidden = true;
+        document.getElementById("updateSettingsContainer").hidden = true;
+        if (updateDisabled && AppConstants.MOZ_MAINTENANCE_SERVICE) {
+          document.getElementById("useService").hidden = true;
+        }
+      } else {
+        // Start with no option selected since we are still reading the value
+        document.getElementById("autoDesktop").removeAttribute("selected");
+        document.getElementById("manualDesktop").removeAttribute("selected");
+        // Start reading the correct value from the disk
+        this.updateReadPrefs();
+        setEventListener(
+          "updateRadioGroup",
+          "command",
+          gGeneralPane.updateWritePrefs
+        );
+      }
+
+      let defaults = Services.prefs.getDefaultBranch(null);
+      let distroId = defaults.getCharPref("distribution.id", "");
+      if (distroId) {
+        let distroVersion = defaults.getCharPref("distribution.version", "");
+
+        let distroIdField = document.getElementById("distributionId");
+        distroIdField.value = distroId + " - " + distroVersion;
+        distroIdField.style.display = "block";
+
+        let distroAbout = defaults.getStringPref("distribution.about", "");
+        if (distroAbout) {
+          let distroField = document.getElementById("distribution");
+          distroField.value = distroAbout;
+          distroField.style.display = "block";
+        }
+      }
+
+      if (AppConstants.platform == "win") {
+        // On Windows, the Application Update setting is an installation-
+        // specific preference, not a profile-specific one. Show a warning to
+        // inform users of this.
+        let updateContainer = document.getElementById(
+          "updateSettingsContainer"
+        );
+        updateContainer.classList.add("updateSettingCrossUserWarningContainer");
+        document.getElementById("updateSettingCrossUserWarning").hidden = false;
+      }
+
+      if (AppConstants.MOZ_MAINTENANCE_SERVICE) {
+        // Check to see if the maintenance service is installed.
+        // If it isn't installed, don't show the preference at all.
+        let installed;
+        try {
+          let wrk = Cc["@mozilla.org/windows-registry-key;1"].createInstance(
+            Ci.nsIWindowsRegKey
+          );
+          wrk.open(
+            wrk.ROOT_KEY_LOCAL_MACHINE,
+            "SOFTWARE\\Mozilla\\MaintenanceService",
+            wrk.ACCESS_READ | wrk.WOW64_64
+          );
+          installed = wrk.readIntValue("Installed");
+          wrk.close();
+        } catch (e) {}
+        if (installed != 1) {
+          document.getElementById("useService").hidden = true;
+        }
+      }
+
+      let version = AppConstants.MOZ_APP_VERSION_DISPLAY;
+
+      // Include the build ID and display warning if this is an "a#" (nightly) build
+      if (/a\d+$/.test(version)) {
+        let buildID = Services.appinfo.appBuildID;
+        let year = buildID.slice(0, 4);
+        let month = buildID.slice(4, 6);
+        let day = buildID.slice(6, 8);
+        version += ` (${year}-${month}-${day})`;
+      }
+
+      // Append "(32-bit)" or "(64-bit)" build architecture to the version number:
+      let bundle = Services.strings.createBundle(
+        "chrome://messenger/locale/messenger.properties"
+      );
+      let archResource = Services.appinfo.is64Bit
+        ? "aboutDialog.architecture.sixtyFourBit"
+        : "aboutDialog.architecture.thirtyTwoBit";
+      let arch = bundle.GetStringFromName(archResource);
+      version += ` (${arch})`;
+
+      document.l10n.setAttributes(
+        document.getElementById("version"),
+        "update-app-version",
+        { version }
+      );
+
+      if (!AppConstants.NIGHTLY_BUILD) {
+        // Show a release notes link if we have a URL.
+        let relNotesLink = document.getElementById("releasenotes");
+        let relNotesPrefType = Services.prefs.getPrefType(
+          "app.releaseNotesURL"
+        );
+        if (relNotesPrefType != Services.prefs.PREF_INVALID) {
+          let relNotesURL = Services.urlFormatter.formatURLPref(
+            "app.releaseNotesURL"
+          );
+          if (relNotesURL != "about:blank") {
+            relNotesLink.href = relNotesURL;
+            relNotesLink.hidden = false;
+          }
+        }
+      }
+      // Initialize Application section.
+
+      // Listen for window unload so we can remove our preference observers.
+      window.addEventListener("unload", this);
+
+      Services.obs.addObserver(this, AUTO_UPDATE_CHANGED_TOPIC);
+      Services.prefs.addObserver("mailnews.tags.", this);
+    }
+
+    Preferences.addSyncFromPrefListener(
+      document.getElementById("allowSmartSize"),
+      () => this.readSmartSizeEnabled()
+    );
+
+    let element = document.getElementById("cacheSize");
+    Preferences.addSyncFromPrefListener(element, () => this.readCacheSize());
+    Preferences.addSyncToPrefListener(element, () => this.writeCacheSize());
+    Preferences.addSyncFromPrefListener(menulist, () =>
+      this.readFontSelection()
+    );
+    Preferences.addSyncFromPrefListener(
+      document.getElementById("soundUrlLocation"),
+      () => this.readSoundLocation()
+    );
+
+    if (!Services.policies.isAllowed("about:config")) {
+      document.getElementById("configEditor").disabled = true;
+    }
+  },
+
+  /**
+   * Restores the default start page as the user's start page
+   */
+  restoreDefaultStartPage() {
+    var startPage = Preferences.get("mailnews.start_page.url");
+    startPage.value = startPage.defaultValue;
+  },
+
+  /**
+   * Returns a formatted url corresponding to the value of mailnews.start_page.url
+   * Stores the original value of mailnews.start_page.url
+   */
+  readStartPageUrl() {
+    var pref = Preferences.get("mailnews.start_page.url");
+    this.mStartPageUrl = pref.value;
+    return Services.urlFormatter.formatURL(this.mStartPageUrl);
+  },
+
+  /**
+   * Returns the value of the mailnews start page url represented by the UI.
+   * If the url matches the formatted version of our stored value, then
+   * return the unformatted url.
+   */
+  writeStartPageUrl() {
+    var startPage = document.getElementById("mailnewsStartPageUrl");
+    return Services.urlFormatter.formatURL(this.mStartPageUrl) ==
+      startPage.value
+      ? this.mStartPageUrl
+      : startPage.value;
+  },
+
+  customizeMailAlert() {
+    gSubDialog.open(
+      "chrome://messenger/content/preferences/notifications.xhtml",
+      { features: "resizable=no" }
+    );
+  },
+
+  configureDockOptions() {
+    gSubDialog.open(
+      "chrome://messenger/content/preferences/dockoptions.xhtml",
+      { features: "resizable=no" }
+    );
+  },
+
+  convertURLToLocalFile(aFileURL) {
+    // convert the file url into a nsIFile
+    if (aFileURL) {
+      return Services.io
+        .getProtocolHandler("file")
+        .QueryInterface(Ci.nsIFileProtocolHandler)
+        .getFileFromURLSpec(aFileURL);
+    }
+    return null;
+  },
+
+  readSoundLocation() {
+    var soundUrlLocation = document.getElementById("soundUrlLocation");
+    soundUrlLocation.value = Preferences.get("mail.biff.play_sound.url").value;
+    if (soundUrlLocation.value) {
+      soundUrlLocation.label = this.convertURLToLocalFile(
+        soundUrlLocation.value
+      ).leafName;
+      soundUrlLocation.style.backgroundImage =
+        "url(moz-icon://" + soundUrlLocation.label + "?size=16)";
+    }
+  },
+
+  previewSound() {
+    let sound = Cc["@mozilla.org/sound;1"].createInstance(Ci.nsISound);
+
+    let soundLocation;
+    // soundType radio-group isn't used for macOS so it is not in the XUL file
+    // for the platform.
+    soundLocation =
+      AppConstants.platform == "macosx" ||
+      document.getElementById("soundType").value == 1
+        ? document.getElementById("soundUrlLocation").value
+        : "";
+
+    if (!soundLocation.includes("file://")) {
+      // User has not set any custom sound file to be played
+      sound.playEventSound(Ci.nsISound.EVENT_NEW_MAIL_RECEIVED);
+    } else {
+      // User has set a custom audio file to be played along the alert.
+      sound.play(Services.io.newURI(soundLocation));
+    }
+  },
+
+  browseForSoundFile() {
+    var fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
+
+    // if we already have a sound file, then use the path for that sound file
+    // as the initial path in the dialog.
+    var localFile = this.convertURLToLocalFile(
+      document.getElementById("soundUrlLocation").value
+    );
+    if (localFile) {
+      fp.displayDirectory = localFile.parent;
+    }
+
+    // XXX todo, persist the last sound directory and pass it in
+    fp.init(
+      window,
+      document
+        .getElementById("bundlePreferences")
+        .getString("soundFilePickerTitle"),
+      Ci.nsIFilePicker.modeOpen
+    );
+    fp.appendFilters(Ci.nsIFilePicker.filterAudio);
+    fp.appendFilters(Ci.nsIFilePicker.filterAll);
+
+    fp.open(rv => {
+      if (rv != Ci.nsIFilePicker.returnOK || !fp.file) {
+        return;
+      }
+      // convert the nsIFile into a nsIFile url
+      Preferences.get("mail.biff.play_sound.url").value = fp.fileURL.spec;
+      this.readSoundLocation(); // XXX We shouldn't have to be doing this by hand
+      this.updatePlaySound();
+    });
+  },
+
+  updatePlaySound(soundsDisabled, soundUrlLocation, soundType) {
+    // Update the sound type radio buttons based on the state of the
+    // play sound checkbox.
+    if (soundsDisabled === undefined) {
+      soundsDisabled = !document.getElementById("newMailNotification").checked;
+      soundUrlLocation = document.getElementById("soundUrlLocation").value;
+    }
+
+    // The UI is different on OS X as the user can only choose between letting
+    // the system play a default sound or setting a custom one. Therefore,
+    // "soundTypeEl" does not exist on OS X.
+    if (AppConstants.platform != "macosx") {
+      var soundTypeEl = document.getElementById("soundType");
+      if (soundType === undefined) {
+        soundType = soundTypeEl.value;
+      }
+
+      soundTypeEl.disabled = soundsDisabled;
+      document.getElementById("soundUrlLocation").disabled =
+        soundsDisabled || soundType != 1;
+      document.getElementById("browseForSound").disabled =
+        soundsDisabled || soundType != 1;
+      document.getElementById("playSound").disabled =
+        soundsDisabled || (!soundUrlLocation && soundType != 0);
+    } else {
+      // On OS X, if there is no selected custom sound then default one will
+      // be played. We keep consistency by disabling the "Play sound" checkbox
+      // if the user hasn't selected a custom sound file yet.
+      document.getElementById("newMailNotification").disabled =
+        !soundUrlLocation;
+      document.getElementById("playSound").disabled = !soundUrlLocation;
+      // The sound type radiogroup is hidden, but we have to keep the
+      // play_sound.type pref set appropriately.
+      Preferences.get("mail.biff.play_sound.type").value =
+        !soundsDisabled && soundUrlLocation ? 1 : 0;
+    }
+  },
+
+  updateStartPage() {
+    document.getElementById("mailnewsStartPageUrl").disabled = !Preferences.get(
+      "mailnews.start_page.enabled"
+    ).value;
+    document.getElementById("browseForStartPageUrl").disabled =
+      !Preferences.get("mailnews.start_page.enabled").value;
+  },
+
+  updateShowAlert() {
+    // The button does not exist on all platforms.
+    let customizeAlertButton = document.getElementById("customizeMailAlert");
+    if (customizeAlertButton) {
+      customizeAlertButton.disabled = !Preferences.get("mail.biff.show_alert")
+        .value;
+    }
+    // The checkmark does not exist on all platforms.
+    let systemNotification = document.getElementById(
+      "useSystemNotificationAlert"
+    );
+    if (systemNotification) {
+      systemNotification.disabled = !Preferences.get("mail.biff.show_alert")
+        .value;
+    }
+  },
+
+  updateWebSearch() {
+    let self = this;
+    Services.search.init().then(async () => {
+      let defaultEngine = await Services.search.getDefault();
+      let engineList = document.getElementById("defaultWebSearch");
+      for (let engine of await Services.search.getVisibleEngines()) {
+        let item = engineList.appendItem(engine.name);
+        item.engine = engine;
+        item.className = "menuitem-iconic";
+        item.setAttribute(
+          "image",
+          engine.iconURI
+            ? engine.iconURI.spec
+            : "resource://gre-resources/broken-image.png"
+        );
+        if (engine == defaultEngine) {
+          engineList.selectedItem = item;
+        }
+      }
+      self.defaultEngines = await Services.search.getAppProvidedEngines();
+      self.updateRemoveButton();
+
+      engineList.addEventListener("command", async () => {
+        await Services.search.setDefault(
+          engineList.selectedItem.engine,
+          Ci.nsISearchService.CHANGE_REASON_USER
+        );
+        self.updateRemoveButton();
+      });
+    });
+  },
+
+  // Caches the default engines so we only retrieve them once.
+  defaultEngines: null,
+
+  async updateRemoveButton() {
+    let engineList = document.getElementById("defaultWebSearch");
+    let removeButton = document.getElementById("removeSearchEngine");
+    if (this.defaultEngines.includes(await Services.search.getDefault())) {
+      // Don't allow deletion of a default engine (saves us having a 'restore' button).
+      removeButton.disabled = true;
+    } else {
+      // Don't allow removal of last engine. This shouldn't happen since there should
+      // always be default engines.
+      removeButton.disabled = engineList.itemCount <= 1;
+    }
+  },
+
+  /**
+   * Look up OpenSearch Description URL.
+   *
+   * @param url - the url to use as basis for discovery
+   */
+  async lookupOpenSearch(url) {
+    let response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Bad response for url=${url}`);
+    }
+    let contentType = response.headers.get("Content-Type")?.toLowerCase();
+    if (
+      contentType == "application/opensearchdescription+xml" ||
+      contentType == "application/xml" ||
+      contentType == "text/xml"
+    ) {
+      return url;
+    }
+    let doc = new DOMParser().parseFromString(
+      await response.text(),
+      "text/html"
+    );
+    let auto = doc.querySelector(
+      "link[rel='search'][type='application/opensearchdescription+xml']"
+    );
+    if (!auto) {
+      throw new Error(`No provider discovered for url=${url}`);
+    }
+    return /^https?:/.test(auto.href)
+      ? auto.href
+      : new URL(url).origin + auto.href;
+  },
+
+  async addSearchEngine() {
+    let input = { value: "https://" };
+    let [title, text] = await document.l10n.formatValues([
+      "add-opensearch-provider-title",
+      "add-opensearch-provider-text",
+    ]);
+    let result = Services.prompt.prompt(window, title, text, input, null, {
+      value: false,
+    });
+    input.value = input.value.trim();
+    if (!result || !input.value || input.value == "https://") {
+      return;
+    }
+    let url = input.value;
+    let engine;
+    try {
+      url = await this.lookupOpenSearch(url);
+      engine = await Services.search.addOpenSearchEngine(url, null);
+    } catch (reason) {
+      let [title, text] = await document.l10n.formatValues([
+        { id: "adding-opensearch-provider-failed-title" },
+        { id: "adding-opensearch-provider-failed-text", args: { url } },
+      ]);
+      Services.prompt.alert(window, title, text);
+      return;
+    }
+    // Wait a bit, so the engine iconURI has time to be fetched.
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(r => setTimeout(r, 500));
+
+    // Add new engine to the list, make the added engine the default.
+    let engineList = document.getElementById("defaultWebSearch");
+    let item = engineList.appendItem(engine.name);
+    item.engine = engine;
+    item.className = "menuitem-iconic";
+    item.setAttribute(
+      "image",
+      engine.iconURI
+        ? engine.iconURI.spec
+        : "resource://gre-resources/broken-image.png"
+    );
+    engineList.selectedIndex =
+      engineList.firstElementChild.childElementCount - 1;
+    await Services.search.setDefault(
+      engineList.selectedItem.engine,
+      Ci.nsISearchService.CHANGE_REASON_USER
+    );
+    this.updateRemoveButton();
+  },
+
+  async removeSearchEngine() {
+    // Deletes the current engine. Firefox does a better job since it
+    // shows all the engines in the list. But better than nothing.
+    let defaultEngine = await Services.search.getDefault();
+    let engineList = document.getElementById("defaultWebSearch");
+    for (let i = 0; i < engineList.itemCount; i++) {
+      let item = engineList.getItemAtIndex(i);
+      if (item.engine == defaultEngine) {
+        await Services.search.removeEngine(item.engine);
+        item.remove();
+        engineList.selectedIndex = 0;
+        await Services.search.setDefault(
+          engineList.selectedItem.engine,
+          Ci.nsISearchService.CHANGE_REASON_USER
+        );
+        this.updateRemoveButton();
+        break;
+      }
+    }
+  },
+
+  /**
+   * Checks whether Thunderbird is currently registered with the operating
+   * system as the default app for mail, rss and news.  If Thunderbird is not
+   * currently the default app, the user is given the option of making it the
+   * default for each type; otherwise, the user is informed that Thunderbird is
+   * already the default.
+   */
+  checkDefaultNow(aAppType) {
+    if (!this.mShellServiceWorking) {
+      return;
+    }
+
+    // otherwise, bring up the default client dialog
+    gSubDialog.open(
+      "chrome://messenger/content/systemIntegrationDialog.xhtml",
+      { features: "resizable=no" },
+      "calledFromPrefs"
+    );
+  },
+
+  // FONTS
+
+  /**
+   * Populates the default font list in UI.
+   */
+  _rebuildFonts() {
+    var langGroupPref = Preferences.get("font.language.group");
+    var isSerif =
+      gGeneralPane._readDefaultFontTypeForLanguage(langGroupPref.value) ==
+      "serif";
+    gGeneralPane._selectDefaultLanguageGroup(langGroupPref.value, isSerif);
+  },
+
+  /**
+   * Select the default language group.
+   */
+  _selectDefaultLanguageGroupPromise: Promise.resolve(),
+
+  _selectDefaultLanguageGroup(aLanguageGroup, aIsSerif) {
+    this._selectDefaultLanguageGroupPromise = (async () => {
+      // Avoid overlapping language group selections by awaiting the resolution
+      // of the previous one.  We do this because this function is re-entrant,
+      // as inserting <preference> elements into the DOM sometimes triggers a call
+      // back into this function.  And since this function is also asynchronous,
+      // that call can enter this function before the previous run has completed,
+      // which would corrupt the font menulists.  Awaiting the previous call's
+      // resolution avoids that fate.
+      await this._selectDefaultLanguageGroupPromise;
+
+      const kFontNameFmtSerif = "font.name.serif.%LANG%";
+      const kFontNameFmtSansSerif = "font.name.sans-serif.%LANG%";
+      const kFontNameListFmtSerif = "font.name-list.serif.%LANG%";
+      const kFontNameListFmtSansSerif = "font.name-list.sans-serif.%LANG%";
+      const kFontSizeFmtVariable = "font.size.variable.%LANG%";
+
+      // Make sure font.name-list is created before font.name so that it's
+      // available at the time readFontSelection below is called.
+      var prefs = [
+        {
+          format: aIsSerif ? kFontNameListFmtSerif : kFontNameListFmtSansSerif,
+          type: "unichar",
+          element: null,
+          fonttype: aIsSerif ? "serif" : "sans-serif",
+        },
+        {
+          format: aIsSerif ? kFontNameFmtSerif : kFontNameFmtSansSerif,
+          type: "fontname",
+          element: "defaultFont",
+          fonttype: aIsSerif ? "serif" : "sans-serif",
+        },
+        {
+          format: kFontSizeFmtVariable,
+          type: "int",
+          element: "defaultFontSize",
+          fonttype: null,
+        },
+      ];
+
+      for (var i = 0; i < prefs.length; ++i) {
+        var preference = Preferences.get(
+          prefs[i].format.replace(/%LANG%/, aLanguageGroup)
+        );
+        if (!preference) {
+          preference = Preferences.add({
+            id: prefs[i].format.replace(/%LANG%/, aLanguageGroup),
+            type: prefs[i].type,
+          });
+        }
+
+        if (!prefs[i].element) {
+          continue;
+        }
+
+        var element = document.getElementById(prefs[i].element);
+        if (element) {
+          if (prefs[i].fonttype) {
+            await FontBuilder.buildFontList(
+              aLanguageGroup,
+              prefs[i].fonttype,
+              element
+            );
+          }
+
+          element.setAttribute("preference", preference.id);
+
+          preference.setElementValue(element);
+        }
+      }
+    })().catch(console.error);
+  },
+
+  /**
+   * Displays the fonts dialog, where web page font names and sizes can be
+   * configured.
+   */
+  configureFonts() {
+    gSubDialog.open("chrome://messenger/content/preferences/fonts.xhtml", {
+      features: "resizable=no",
+    });
+  },
+
+  /**
+   * Displays the colors dialog, where default web page/link/etc. colors can be
+   * configured.
+   */
+  configureColors() {
+    gSubDialog.open("chrome://messenger/content/preferences/colors.xhtml", {
+      features: "resizable=no",
+    });
+  },
+
+  /**
+   * Returns the type of the current default font for the language denoted by
+   * aLanguageGroup.
+   */
+  _readDefaultFontTypeForLanguage(aLanguageGroup) {
+    const kDefaultFontType = "font.default.%LANG%";
+    var defaultFontTypePref = kDefaultFontType.replace(
+      /%LANG%/,
+      aLanguageGroup
+    );
+    var preference = Preferences.get(defaultFontTypePref);
+    if (!preference) {
+      Preferences.add({
+        id: defaultFontTypePref,
+        type: "string",
+        name: defaultFontTypePref,
+      }).on("change", gGeneralPane._rebuildFonts);
+    }
+
+    // We should return preference.value here, but we can't wait for the binding to load,
+    // or things get really messy. Fortunately this will give the same answer.
+    return Services.prefs.getCharPref(defaultFontTypePref);
+  },
+
+  /**
+   * Determine the appropriate value to select for defaultFont, for the
+   * following cases:
+   * - there is no setting
+   * - the font selected by the user is no longer present (e.g. deleted from
+   *   fonts folder)
+   */
+  readFontSelection() {
+    let element = document.getElementById("defaultFont");
+    let preference = Preferences.get(element.getAttribute("preference"));
+    if (preference.value) {
+      let fontItem = element.querySelector(
+        '[value="' + preference.value + '"]'
+      );
+
+      // There is a setting that actually is in the list. Respect it.
+      if (fontItem) {
+        return undefined;
+      }
+    }
+
+    let defaultValue =
+      element.firstElementChild.firstElementChild.getAttribute("value");
+    let languagePref = Preferences.get("font.language.group");
+    let defaultType = this._readDefaultFontTypeForLanguage(languagePref.value);
+    let listPref = Preferences.get(
+      "font.name-list." + defaultType + "." + languagePref.value
+    );
+    if (!listPref) {
+      return defaultValue;
+    }
+
+    let fontNames = listPref.value.split(",");
+
+    for (let fontName of fontNames) {
+      let fontItem = element.querySelector('[value="' + fontName.trim() + '"]');
+      if (fontItem) {
+        return fontItem.getAttribute("value");
+      }
+    }
+    return defaultValue;
+  },
+
+  async formatLocaleSetLabels() {
+    // HACK: calling getLocaleDisplayNames may fail the first time due to
+    // synchronous loading of the .ftl files. If we load the files and wait
+    // for a known value asynchronously, no such failure will happen.
+    await new Localization([
+      "toolkit/intl/languageNames.ftl",
+      "toolkit/intl/regionNames.ftl",
+    ]).formatValue("language-name-en");
+
+    const osprefs = Cc["@mozilla.org/intl/ospreferences;1"].getService(
+      Ci.mozIOSPreferences
+    );
+    let appLocale = Services.locale.appLocalesAsBCP47[0];
+    let rsLocale = osprefs.regionalPrefsLocales[0];
+    let names = Services.intl.getLocaleDisplayNames(undefined, [
+      appLocale,
+      rsLocale,
+    ]);
+    let appLocaleRadio = document.getElementById("appLocale");
+    let rsLocaleRadio = document.getElementById("rsLocale");
+    let appLocaleLabel = this._prefsBundle.getFormattedString(
+      "appLocale.label",
+      [names[0]]
+    );
+    let rsLocaleLabel = this._prefsBundle.getFormattedString("rsLocale.label", [
+      names[1],
+    ]);
+    appLocaleRadio.setAttribute("label", appLocaleLabel);
+    rsLocaleRadio.setAttribute("label", rsLocaleLabel);
+    appLocaleRadio.accessKey = this._prefsBundle.getString(
+      "appLocale.accesskey"
+    );
+    rsLocaleRadio.accessKey = this._prefsBundle.getString("rsLocale.accesskey");
+  },
+
+  // Load the preferences string bundle for other locales with fallbacks.
+  getBundleForLocales(newLocales) {
+    let locales = Array.from(
+      new Set([
+        ...newLocales,
+        ...Services.locale.requestedLocales,
+        Services.locale.lastFallbackLocale,
+      ])
+    );
+    return new Localization(
+      ["messenger/preferences/preferences.ftl", "branding/brand.ftl"],
+      false,
+      undefined,
+      locales
+    );
+  },
+
+  initPrimaryMessengerLanguageUI() {
+    gGeneralPane.updatePrimaryMessengerLanguageUI(
+      Services.locale.requestedLocale
+    );
+  },
+
+  /**
+   * Update the available list of locales and select the locale that the user
+   * is "selecting". This could be the currently requested locale or a locale
+   * that the user would like to switch to after confirmation.
+   *
+   * @param {string} selected - The selected BCP 47 locale.
+   */
+  async updatePrimaryMessengerLanguageUI(selected) {
+    // HACK: calling getLocaleDisplayNames may fail the first time due to
+    // synchronous loading of the .ftl files. If we load the files and wait
+    // for a known value asynchronously, no such failure will happen.
+    await new Localization([
+      "toolkit/intl/languageNames.ftl",
+      "toolkit/intl/regionNames.ftl",
+    ]).formatValue("language-name-en");
+
+    let available = await getAvailableLocales();
+    let localeNames = Services.intl.getLocaleDisplayNames(
+      undefined,
+      available,
+      { preferNative: true }
+    );
+    let locales = available.map((code, i) => ({ code, name: localeNames[i] }));
+    locales.sort((a, b) => a.name > b.name);
+
+    let fragment = document.createDocumentFragment();
+    for (let { code, name } of locales) {
+      let menuitem = document.createXULElement("menuitem");
+      menuitem.setAttribute("value", code);
+      menuitem.setAttribute("label", name);
+      fragment.appendChild(menuitem);
+    }
+
+    // Add an option to search for more languages if downloading is supported.
+    if (Services.prefs.getBoolPref("intl.multilingual.downloadEnabled")) {
+      let menuitem = document.createXULElement("menuitem");
+      menuitem.id = "primaryMessengerLocaleSearch";
+      menuitem.setAttribute(
+        "label",
+        await document.l10n.formatValue("messenger-languages-search")
+      );
+      menuitem.setAttribute("value", "search");
+      menuitem.addEventListener("command", () => {
+        gGeneralPane.showMessengerLanguagesSubDialog({ search: true });
+      });
+      fragment.appendChild(menuitem);
+    }
+
+    let menulist = document.getElementById("primaryMessengerLocale");
+    let menupopup = menulist.querySelector("menupopup");
+    menupopup.textContent = "";
+    menupopup.appendChild(fragment);
+    menulist.value = selected;
+
+    document.getElementById("messengerLanguagesBox").hidden = false;
+  },
+
+  /**
+   * Open the messenger languages sub dialog in either the normal mode, or search mode.
+   * The search mode is only available from the menu to change the primary browser
+   * language.
+   *
+   * @param {{ search: boolean }}
+   */
+  showMessengerLanguagesSubDialog({ search }) {
+    let opts = {
+      selectedLocalesForRestart: gGeneralPane.selectedLocalesForRestart,
+      search,
+    };
+    gSubDialog.open(
+      "chrome://messenger/content/preferences/messengerLanguages.xhtml",
+      { closingCallback: this.messengerLanguagesClosed },
+      opts
+    );
+  },
+
+  /**
+   * Returns the assumed script directionality for known Firefox locales. This is
+   * somewhat crude, but should work until Bug 1750781 lands.
+   *
+   * TODO (Bug 1750781) - This should use Intl.LocaleInfo once it is standardized (see
+   * Bug 1693576), rather than maintaining a hardcoded list of RTL locales.
+   *
+   * @param {string} locale
+   * @returns {"ltr" | "rtl"}
+   */
+  getLocaleDirection(locale) {
+    if (
+      locale == "ar" ||
+      locale == "ckb" ||
+      locale == "fa" ||
+      locale == "he" ||
+      locale == "ur"
+    ) {
+      return "rtl";
+    }
+    return "ltr";
+  },
+
+  /**
+   * Determine the transition strategy for switching the locale based on prefs
+   * and the switched locales.
+   *
+   * @param {Array<string>} newLocales - List of BCP 47 locale identifiers.
+   * @returns {"locales-match" | "requires-restart" | "live-reload"}
+   */
+  getLanguageSwitchTransitionType(newLocales) {
+    const { appLocalesAsBCP47 } = Services.locale;
+    if (appLocalesAsBCP47.join(",") === newLocales.join(",")) {
+      // The selected locales match, the order matters.
+      return "locales-match";
+    }
+
+    if (Services.prefs.getBoolPref("intl.multilingual.liveReload")) {
+      if (
+        gGeneralPane.getLocaleDirection(newLocales[0]) !==
+          gGeneralPane.getLocaleDirection(appLocalesAsBCP47[0]) &&
+        !Services.prefs.getBoolPref("intl.multilingual.liveReloadBidirectional")
+      ) {
+        // Bug 1750852: The directionality of the text changed, which requires a restart
+        // until the quality of the switch can be improved.
+        return "requires-restart";
+      }
+
+      return "live-reload";
+    }
+
+    return "requires-restart";
+  },
+
+  /* Show or hide the confirm change message bar based on the updated ordering. */
+  messengerLanguagesClosed() {
+    // When the subdialog is closed, settings are stored on gMessengerLanguagesDialog.
+    // The next time the dialog is opened, a new gMessengerLanguagesDialog is created.
+    let { selected } = this.gMessengerLanguagesDialog;
+
+    if (!selected) {
+      // No locales were selected. Cancel the operation.
+      return;
+    }
+
+    switch (gGeneralPane.getLanguageSwitchTransitionType(selected)) {
+      case "requires-restart":
+        gGeneralPane.showConfirmLanguageChangeMessageBar(selected);
+        gGeneralPane.updatePrimaryMessengerLanguageUI(selected[0]);
+        break;
+      case "live-reload":
+        Services.locale.requestedLocales = selected;
+
+        gGeneralPane.updatePrimaryMessengerLanguageUI(
+          Services.locale.appLocaleAsBCP47
+        );
+        gGeneralPane.hideConfirmLanguageChangeMessageBar();
+        break;
+      case "locales-match":
+        // They matched, so we can reset the UI.
+        gGeneralPane.updatePrimaryMessengerLanguageUI(
+          Services.locale.appLocaleAsBCP47
+        );
+        gGeneralPane.hideConfirmLanguageChangeMessageBar();
+        break;
+      default:
+        throw new Error("Unhandled transition type.");
+    }
+  },
+
+  /* Show the confirmation message bar to allow a restart into the new locales. */
+  async showConfirmLanguageChangeMessageBar(locales) {
+    let messageBar = document.getElementById("confirmMessengerLanguage");
+
+    // Get the bundle for the new locale.
+    let newBundle = this.getBundleForLocales(locales);
+
+    // Find the messages and labels.
+    let messages = await Promise.all(
+      [newBundle, document.l10n].map(async bundle =>
+        bundle.formatValue("confirm-messenger-language-change-description")
+      )
+    );
+    let buttonLabels = await Promise.all(
+      [newBundle, document.l10n].map(async bundle =>
+        bundle.formatValue("confirm-messenger-language-change-button")
+      )
+    );
+
+    // If both the message and label are the same, just include one row.
+    if (messages[0] == messages[1] && buttonLabels[0] == buttonLabels[1]) {
+      messages.pop();
+      buttonLabels.pop();
+    }
+
+    let contentContainer = messageBar.querySelector(
+      ".message-bar-content-container"
+    );
+    contentContainer.textContent = "";
+
+    for (let i = 0; i < messages.length; i++) {
+      let messageContainer = document.createXULElement("hbox");
+      messageContainer.classList.add("message-bar-content");
+      messageContainer.setAttribute("flex", "1");
+      messageContainer.setAttribute("align", "center");
+
+      let description = document.createXULElement("description");
+      description.classList.add("message-bar-description");
+
+      if (i == 0 && gGeneralPane.getLocaleDirection(locales[0]) === "rtl") {
+        description.classList.add("rtl-locale");
+      }
+
+      description.setAttribute("flex", "1");
+      description.textContent = messages[i];
+      messageContainer.appendChild(description);
+
+      let button = document.createXULElement("button");
+      button.addEventListener("command", gGeneralPane.confirmLanguageChange);
+      button.classList.add("message-bar-button");
+      button.setAttribute("locales", locales.join(","));
+      button.setAttribute("label", buttonLabels[i]);
+      messageContainer.appendChild(button);
+
+      contentContainer.appendChild(messageContainer);
+    }
+
+    messageBar.hidden = false;
+    this.selectedLocalesForRestart = locales;
+  },
+
+  hideConfirmLanguageChangeMessageBar() {
+    let messageBar = document.getElementById("confirmMessengerLanguage");
+    messageBar.hidden = true;
+    let contentContainer = messageBar.querySelector(
+      ".message-bar-content-container"
+    );
+    contentContainer.textContent = "";
+    this.requestingLocales = null;
+  },
+
+  /* Confirm the locale change and restart the Thunderbird in the new locale. */
+  confirmLanguageChange(event) {
+    let localesString = (event.target.getAttribute("locales") || "").trim();
+    if (!localesString || localesString.length == 0) {
+      return;
+    }
+    let locales = localesString.split(",");
+    Services.locale.requestedLocales = locales;
+
+    // Restart with the new locale.
+    let cancelQuit = Cc["@mozilla.org/supports-PRBool;1"].createInstance(
+      Ci.nsISupportsPRBool
+    );
+    Services.obs.notifyObservers(
+      cancelQuit,
+      "quit-application-requested",
+      "restart"
+    );
+    if (!cancelQuit.data) {
+      Services.startup.quit(
+        Services.startup.eAttemptQuit | Services.startup.eRestart
+      );
+    }
+  },
+
+  /* Show or hide the confirm change message bar based on the new locale. */
+  onPrimaryMessengerLanguageMenuChange(event) {
+    let locale = event.target.value;
+
+    if (locale == "search") {
+      return;
+    } else if (locale == Services.locale.appLocaleAsBCP47) {
+      this.hideConfirmLanguageChangeMessageBar();
+      return;
+    }
+
+    let newLocales = Array.from(
+      new Set([locale, ...Services.locale.requestedLocales]).values()
+    );
+
+    switch (gGeneralPane.getLanguageSwitchTransitionType(newLocales)) {
+      case "requires-restart":
+        // Prepare to change the locales, as they were different.
+        gGeneralPane.showConfirmLanguageChangeMessageBar(newLocales);
+        gGeneralPane.updatePrimaryMessengerLanguageUI(newLocales[0]);
+        break;
+      case "live-reload":
+        Services.locale.requestedLocales = newLocales;
+        gGeneralPane.updatePrimaryMessengerLanguageUI(
+          Services.locale.appLocaleAsBCP47
+        );
+        gGeneralPane.hideConfirmLanguageChangeMessageBar();
+        break;
+      case "locales-match":
+        // They matched, so we can reset the UI.
+        gGeneralPane.updatePrimaryMessengerLanguageUI(
+          Services.locale.appLocaleAsBCP47
+        );
+        gGeneralPane.hideConfirmLanguageChangeMessageBar();
+        break;
+      default:
+        throw new Error("Unhandled transition type.");
+    }
+  },
+
+  // appends the tag to the tag list box
+  appendTagItem(aTagName, aKey, aColor) {
+    let item = this.mTagListBox.appendItem(aTagName, aKey);
+    item.style.color = aColor;
+    return item;
+  },
+
+  buildTagList() {
+    let tagArray = MailServices.tags.getAllTags();
+    for (let i = 0; i < tagArray.length; ++i) {
+      let taginfo = tagArray[i];
+      this.appendTagItem(taginfo.tag, taginfo.key, taginfo.color);
+    }
+  },
+
+  removeTag() {
+    var index = this.mTagListBox.selectedIndex;
+    if (index >= 0) {
+      var itemToRemove = this.mTagListBox.getItemAtIndex(index);
+      MailServices.tags.deleteKey(itemToRemove.getAttribute("value"));
+    }
+  },
+
+  /**
+   * Open the edit tag dialog
+   */
+  editTag() {
+    var index = this.mTagListBox.selectedIndex;
+    if (index >= 0) {
+      var tagElToEdit = this.mTagListBox.getItemAtIndex(index);
+      var args = {
+        result: "",
+        keyToEdit: tagElToEdit.getAttribute("value"),
+      };
+      gSubDialog.open(
+        "chrome://messenger/content/preferences/tagDialog.xhtml",
+        { features: "resizable=no" },
+        args
+      );
+    }
+  },
+
+  addTag() {
+    var args = { result: "", okCallback: addTagCallback };
+    gSubDialog.open(
+      "chrome://messenger/content/preferences/tagDialog.xhtml",
+      { features: "resizable=no" },
+      args
+    );
+  },
+
+  onSelectTag() {
+    let btnEdit = document.getElementById("editTagButton");
+    let listBox = document.getElementById("tagList");
+
+    if (listBox.selectedCount > 0) {
+      btnEdit.disabled = false;
+    } else {
+      btnEdit.disabled = true;
+    }
+
+    document.getElementById("removeTagButton").disabled = btnEdit.disabled;
+  },
+
+  /**
+   * Enable/disable the options of automatic marking as read depending on the
+   * state of the automatic marking feature.
+   */
+  updateMarkAsReadOptions() {
+    let enableRadioGroup = Preferences.get(
+      "mailnews.mark_message_read.auto"
+    ).value;
+    let autoMarkAsPref = Preferences.get("mailnews.mark_message_read.delay");
+    let autoMarkDisabled = !enableRadioGroup || autoMarkAsPref.locked;
+    document.getElementById("markAsReadAutoPreferences").disabled =
+      autoMarkDisabled;
+    document.getElementById("secondsLabel").disabled = autoMarkDisabled;
+    gGeneralPane.updateMarkAsReadTextbox();
+  },
+
+  /**
+   * Automatically enable/disable delay textbox depending on state of the
+   * Mark As Read On Delay feature.
+   */
+  updateMarkAsReadTextbox() {
+    let radioGroupEnabled = Preferences.get(
+      "mailnews.mark_message_read.auto"
+    ).value;
+    let textBoxEnabled = Preferences.get(
+      "mailnews.mark_message_read.delay"
+    ).value;
+    let intervalPref = Preferences.get(
+      "mailnews.mark_message_read.delay.interval"
+    );
+
+    let delayTextbox = document.getElementById("markAsReadDelay");
+    delayTextbox.disabled =
+      !radioGroupEnabled || !textBoxEnabled || intervalPref.locked;
+    if (document.activeElement.id == "markAsReadAutoPreferences") {
+      delayTextbox.focus();
+    }
+  },
+
+  /**
+   * Display the return receipts configuration dialog.
+   */
+  showReturnReceipts() {
+    gSubDialog.open("chrome://messenger/content/preferences/receipts.xhtml", {
+      features: "resizable=no",
+    });
+  },
+
+  /**
+   * Show the about:config page in a tab.
+   */
+  showConfigEdit() {
+    // If the about:config tab is already open, switch to the tab.
+    let mainWin = Services.wm.getMostRecentWindow("mail:3pane");
+    let tabmail = mainWin.document.getElementById("tabmail");
+    for (let tabInfo of tabmail.tabInfo) {
+      let tab = tabmail.getTabForBrowser(tabInfo.browser);
+      if (tab?.urlbar?.value == "about:config") {
+        tabmail.switchToTab(tabInfo);
+        return;
+      }
+    }
+    // Wasn't open already. Open in a new tab.
+    tabmail.openTab("contentTab", { url: "about:config" });
+  },
+
+  /**
+   * Display the the connection settings dialog.
+   */
+  showConnections() {
+    gSubDialog.open("chrome://messenger/content/preferences/connection.xhtml");
+  },
+
+  /**
+   * Display the the offline settings dialog.
+   */
+  showOffline() {
+    gSubDialog.open("chrome://messenger/content/preferences/offline.xhtml", {
+      features: "resizable=no",
+    });
+  },
+
+  /*
+   * browser.cache.disk.capacity
+   * - the size of the browser cache in KB
+   */
+
+  // Retrieves the amount of space currently used by disk cache
+  updateActualCacheSize() {
+    let actualSizeLabel = document.getElementById("actualDiskCacheSize");
+    let prefStrBundle = document.getElementById("bundlePreferences");
+
+    // Needs to root the observer since cache service keeps only a weak reference.
+    this.observer = {
+      onNetworkCacheDiskConsumption(consumption) {
+        let size = DownloadUtils.convertByteUnits(consumption);
+        // The XBL binding for the string bundle may have been destroyed if
+        // the page was closed before this callback was executed.
+        if (!prefStrBundle.getFormattedString) {
+          return;
+        }
+        actualSizeLabel.value = prefStrBundle.getFormattedString(
+          "actualDiskCacheSize",
+          size
+        );
+      },
+
+      QueryInterface: ChromeUtils.generateQI([
+        "nsICacheStorageConsumptionObserver",
+        "nsISupportsWeakReference",
+      ]),
+    };
+
+    actualSizeLabel.value = prefStrBundle.getString(
+      "actualDiskCacheSizeCalculated"
+    );
+
+    try {
+      Services.cache2.asyncGetDiskConsumption(this.observer);
+    } catch (e) {}
+  },
+
+  updateCacheSizeUI(smartSizeEnabled) {
+    document.getElementById("useCacheBefore").disabled = smartSizeEnabled;
+    document.getElementById("cacheSize").disabled = smartSizeEnabled;
+    document.getElementById("useCacheAfter").disabled = smartSizeEnabled;
+  },
+
+  readSmartSizeEnabled() {
+    // The smart_size.enabled preference element is inverted="true", so its
+    // value is the opposite of the actual pref value
+    var disabled = Preferences.get(
+      "browser.cache.disk.smart_size.enabled"
+    ).value;
+    this.updateCacheSizeUI(!disabled);
+  },
+
+  /**
+   * Converts the cache size from units of KB to units of MB and returns that
+   * value.
+   */
+  readCacheSize() {
+    var preference = Preferences.get("browser.cache.disk.capacity");
+    return preference.value / 1024;
+  },
+
+  /**
+   * Converts the cache size as specified in UI (in MB) to KB and returns that
+   * value.
+   */
+  writeCacheSize() {
+    var cacheSize = document.getElementById("cacheSize");
+    var intValue = parseInt(cacheSize.value, 10);
+    return isNaN(intValue) ? 0 : intValue * 1024;
+  },
+
+  /**
+   * Clears the cache.
+   */
+  clearCache() {
+    try {
+      Services.cache2.clear();
+    } catch (ex) {}
+    this.updateActualCacheSize();
+  },
+
+  updateCompactOptions() {
+    let disabled =
+      !Preferences.get("mail.prompt_purge_threshhold").value ||
+      Preferences.get("mail.purge_threshhold_mb").locked;
+
+    document.getElementById("offlineCompactFolderMin").disabled = disabled;
+    document.getElementById("offlineCompactFolderAutomatically").disabled =
+      disabled;
+  },
+
+  /**
+   * Set the default store contract ID.
+   */
+  updateDefaultStore(storeID) {
+    Services.prefs.setCharPref("mail.serverDefaultStoreContractID", storeID);
+  },
+
+  /**
+   * When the user toggles the layers.acceleration.disabled pref,
+   * sync its new value to the gfx.direct2d.disabled pref too.
+   * Note that layers.acceleration.disabled is inverted.
+   */
+  updateHardwareAcceleration() {
+    if (AppConstants.platform == "win") {
+      let preference = Preferences.get("layers.acceleration.disabled");
+      Services.prefs.setBoolPref("gfx.direct2d.disabled", !preference.value);
+    }
+  },
+
+  /**
+   * Selects the correct item in the update radio group
+   */
+  async updateReadPrefs() {
+    if (
+      AppConstants.MOZ_UPDATER &&
+      (!Services.policies || Services.policies.isAllowed("appUpdate")) &&
+      !gIsPackagedApp
+    ) {
+      let radiogroup = document.getElementById("updateRadioGroup");
+      radiogroup.disabled = true;
+      try {
+        let enabled = await UpdateUtils.getAppUpdateAutoEnabled();
+        radiogroup.value = enabled;
+        radiogroup.disabled = false;
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  },
+
+  /**
+   * Writes the value of the update radio group to the disk
+   */
+  async updateWritePrefs() {
+    if (
+      AppConstants.MOZ_UPDATER &&
+      (!Services.policies || Services.policies.isAllowed("appUpdate")) &&
+      !gIsPackagedApp
+    ) {
+      let radiogroup = document.getElementById("updateRadioGroup");
+      let updateAutoValue = radiogroup.value == "true";
+      radiogroup.disabled = true;
+      try {
+        await UpdateUtils.setAppUpdateAutoEnabled(updateAutoValue);
+        radiogroup.disabled = false;
+      } catch (error) {
+        console.error(error);
+        await this.updateReadPrefs();
+        await this.reportUpdatePrefWriteError();
+        return;
+      }
+
+      // If the value was changed to false the user should be given the option
+      // to discard an update if there is one.
+      if (!updateAutoValue) {
+        await this.checkUpdateInProgress();
+      }
+    }
+  },
+
+  async reportUpdatePrefWriteError() {
+    let [title, message] = await document.l10n.formatValues([
+      { id: "update-setting-write-failure-title" },
+      {
+        id: "update-setting-write-failure-message",
+        args: { path: UpdateUtils.configFilePath },
+      },
+    ]);
+
+    // Set up the Ok Button
+    let buttonFlags =
+      Services.prompt.BUTTON_POS_0 * Services.prompt.BUTTON_TITLE_OK;
+    Services.prompt.confirmEx(
+      window,
+      title,
+      message,
+      buttonFlags,
+      null,
+      null,
+      null,
+      null,
+      {}
+    );
+  },
+
+  async checkUpdateInProgress() {
+    let um = Cc["@mozilla.org/updates/update-manager;1"].getService(
+      Ci.nsIUpdateManager
+    );
+    if (!um.readyUpdate && !um.downloadingUpdate) {
+      return;
+    }
+
+    let [title, message, okButton, cancelButton] =
+      await document.l10n.formatValues([
+        { id: "update-in-progress-title" },
+        { id: "update-in-progress-message" },
+        { id: "update-in-progress-ok-button" },
+        { id: "update-in-progress-cancel-button" },
+      ]);
+
+    // Continue is the cancel button which is BUTTON_POS_1 and is set as the
+    // default so pressing escape or using a platform standard method of closing
+    // the UI will not discard the update.
+    let buttonFlags =
+      Ci.nsIPrompt.BUTTON_TITLE_IS_STRING * Ci.nsIPrompt.BUTTON_POS_0 +
+      Ci.nsIPrompt.BUTTON_TITLE_IS_STRING * Ci.nsIPrompt.BUTTON_POS_1 +
+      Ci.nsIPrompt.BUTTON_POS_1_DEFAULT;
+
+    let rv = Services.prompt.confirmEx(
+      window,
+      title,
+      message,
+      buttonFlags,
+      okButton,
+      cancelButton,
+      null,
+      null,
+      {}
+    );
+    if (rv != 1) {
+      let aus = Cc["@mozilla.org/updates/update-service;1"].getService(
+        Ci.nsIApplicationUpdateService
+      );
+      aus.stopDownload();
+      um.cleanupReadyUpdate();
+      um.cleanupDownloadingUpdate();
+    }
+  },
+
+  showUpdates() {
+    gSubDialog.open("chrome://mozapps/content/update/history.xhtml");
+  },
+
+  _loadAppHandlerData() {
+    this._loadInternalHandlers();
+    this._loadApplicationHandlers();
+  },
+
+  _loadInternalHandlers() {
+    const internalHandlers = [new PDFHandlerInfoWrapper()];
+    for (const internalHandler of internalHandlers) {
+      if (internalHandler.enabled) {
+        this._handledTypes.set(internalHandler.type, internalHandler);
+      }
+    }
+  },
+
+  /**
+   * Load the set of handlers defined by the application datastore.
+   */
+  _loadApplicationHandlers() {
+    for (let wrappedHandlerInfo of gHandlerService.enumerate()) {
+      let type = wrappedHandlerInfo.type;
+
+      let handlerInfoWrapper;
+      if (this._handledTypes.has(type)) {
+        handlerInfoWrapper = this._handledTypes.get(type);
+      } else {
+        handlerInfoWrapper = new HandlerInfoWrapper(type, wrappedHandlerInfo);
+        this._handledTypes.set(type, handlerInfoWrapper);
+      }
+    }
+  },
+
+  // -----------------
+  // View Construction
+
+  _rebuildVisibleTypes() {
+    // Reset the list of visible types and the visible type description.
+    this._visibleTypes.length = 0;
+    this._visibleDescriptions.clear();
+
+    for (let handlerInfo of this._handledTypes.values()) {
+      // We couldn't find any reason to exclude the type, so include it.
+      this._visibleTypes.push(handlerInfo);
+
+      let otherHandlerInfo = this._visibleDescriptions.get(
+        handlerInfo.description
+      );
+      if (!otherHandlerInfo) {
+        // This is the first type with this description that we encountered
+        // while rebuilding the _visibleTypes array this time. Make sure the
+        // flag is reset so we won't add the type to the description.
+        handlerInfo.disambiguateDescription = false;
+        this._visibleDescriptions.set(handlerInfo.description, handlerInfo);
+      } else {
+        // There is at least another type with this description. Make sure we
+        // add the type to the description on both HandlerInfoWrapper objects.
+        handlerInfo.disambiguateDescription = true;
+        otherHandlerInfo.disambiguateDescription = true;
+      }
+    }
+  },
+
+  _rebuildView() {
+    // Clear the list of entries.
+    let tbody = this._handlerTbody;
+    while (tbody.hasChildNodes()) {
+      // Rows kept alive by the _handlerRows map.
+      tbody.removeChild(tbody.lastChild);
+    }
+
+    let sort = this._handlerSort;
+    for (let header of this._handlerSortHeaders) {
+      let icon = header.querySelector("img");
+      if (sort.type === header.getAttribute("sort-type")) {
+        icon.setAttribute(
+          "src",
+          "chrome://messenger/skin/icons/new/nav-down-sm.svg"
+        );
+        if (sort.descending) {
+          /* Rotates the src image to point up. */
+          icon.setAttribute("descending", "");
+          header.setAttribute("aria-sort", "descending");
+        } else {
+          icon.removeAttribute("descending");
+          header.setAttribute("aria-sort", "ascending");
+        }
+      } else {
+        icon.removeAttribute("src");
+        header.setAttribute("aria-sort", "none");
+      }
+    }
+
+    let visibleTypes = this._visibleTypes;
+
+    // If the user is filtering the list, then only show matching types.
+    if (this._filter.value) {
+      visibleTypes = visibleTypes.filter(this._matchesFilter, this);
+    }
+
+    for (let handlerInfo of visibleTypes) {
+      let row = this._handlerRows.get(handlerInfo);
+      if (row) {
+        tbody.appendChild(row.node);
+      } else {
+        row = new HandlerRow(handlerInfo, this.onDelete.bind(this));
+        row.constructNodeAndAppend(tbody, this._handlerMenuId);
+        this._handlerMenuId++;
+        this._handlerRows.set(handlerInfo, row);
+      }
+    }
+  },
+
+  _matchesFilter(aType) {
+    var filterValue = this._filter.value.toLowerCase();
+    return (
+      aType.typeDescription.toLowerCase().includes(filterValue) ||
+      aType.actionDescription.toLowerCase().includes(filterValue)
+    );
+  },
+
+  /**
+   * Get the details for the type represented by the given handler info
+   * object.
+   *
+   * @param aHandlerInfo {nsIHandlerInfo} the type to get the extensions for.
+   * @returns {string} the extensions for the type
+   */
+  _typeDetails(aHandlerInfo) {
+    let exts = [];
+    if (aHandlerInfo.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo) {
+      for (let extName of aHandlerInfo.wrappedHandlerInfo.getFileExtensions()) {
+        let ext = "." + extName;
+        if (!exts.includes(ext)) {
+          exts.push(ext);
+        }
+      }
+    }
+    exts.sort();
+    exts = exts.join(", ");
+    if (this._visibleDescriptions.has(aHandlerInfo.description)) {
+      if (exts) {
+        return this._prefsBundle.getFormattedString(
+          "typeDetailsWithTypeAndExt",
+          [aHandlerInfo.type, exts]
+        );
+      }
+      return this._prefsBundle.getFormattedString("typeDetailsWithTypeOrExt", [
+        aHandlerInfo.type,
+      ]);
+    }
+    if (exts) {
+      return this._prefsBundle.getFormattedString("typeDetailsWithTypeOrExt", [
+        exts,
+      ]);
+    }
+    return exts;
+  },
+
+  /**
+   * Whether or not the given handler app is valid.
+   *
+   * @param aHandlerApp {nsIHandlerApp} the handler app in question
+   * @returns {boolean} whether or not it's valid
+   */
+  isValidHandlerApp(aHandlerApp) {
+    if (!aHandlerApp) {
+      return false;
+    }
+
+    if (aHandlerApp instanceof Ci.nsILocalHandlerApp) {
+      return this._isValidHandlerExecutable(aHandlerApp.executable);
+    }
+
+    if (aHandlerApp instanceof Ci.nsIWebHandlerApp) {
+      return aHandlerApp.uriTemplate;
+    }
+
+    if (aHandlerApp instanceof Ci.nsIWebContentHandlerInfo) {
+      return aHandlerApp.uri;
+    }
+
+    return false;
+  },
+
+  _isValidHandlerExecutable(aExecutable) {
+    let isExecutable =
+      aExecutable && aExecutable.exists() && aExecutable.isExecutable();
+    // XXXben - we need to compare this with the running instance executable
+    //          just don't know how to do that via script...
+    // XXXmano TBD: can probably add this to nsIShellService
+    if (AppConstants.platform == "win") {
+      return (
+        isExecutable &&
+        aExecutable.leafName != AppConstants.MOZ_APP_NAME + ".exe"
+      );
+    }
+
+    if (AppConstants.platform == "macosx") {
+      return (
+        isExecutable && aExecutable.leafName != AppConstants.MOZ_MACBUNDLE_NAME
+      );
+    }
+
+    return (
+      isExecutable && aExecutable.leafName != AppConstants.MOZ_APP_NAME + "-bin"
+    );
+  },
+
+  // -------------------
+  // Sorting & Filtering
+
+  /**
+   * Sort the list when the user clicks on a column header. If sortType is
+   * different than the last sort, the sort direction is toggled. Otherwise, the
+   * sort is changed to the new sortType with ascending direction.
+   *
+   * @param {string} sortType - The sort type associated with the column header.
+   */
+  sort(sortType) {
+    let sort = this._handlerSort;
+    if (sort.type === sortType) {
+      sort.descending = !sort.descending;
+    } else {
+      sort.type = sortType;
+      sort.descending = false;
+    }
+    this._sortVisibleTypes();
+    this._rebuildView();
+  },
+
+  /**
+   * Sort the list of visible types by the current sort column/direction.
+   */
+  _sortVisibleTypes() {
+    function sortByType(a, b) {
+      return a.typeDescription
+        .toLowerCase()
+        .localeCompare(b.typeDescription.toLowerCase());
+    }
+
+    function sortByAction(a, b) {
+      return a.actionDescription
+        .toLowerCase()
+        .localeCompare(b.actionDescription.toLowerCase());
+    }
+
+    let sort = this._handlerSort;
+    if (sort.type === "action") {
+      this._visibleTypes.sort(sortByAction);
+    } else {
+      this._visibleTypes.sort(sortByType);
+    }
+    if (sort.descending) {
+      this._visibleTypes.reverse();
+    }
+  },
+
+  focusFilterBox() {
+    this._filter.focus();
+    this._filter.select();
+  },
+
+  onDelete(handlerRow) {
+    let handlerInfo = handlerRow.handlerInfoWrapper;
+    let index = this._visibleTypes.indexOf(handlerInfo);
+    if (index != -1) {
+      this._visibleTypes.splice(index, 1);
+    }
+
+    let tbody = this._handlerTbody;
+    if (handlerRow.node.parentNode === tbody) {
+      tbody.removeChild(handlerRow.node);
+    }
+
+    this._handledTypes.delete(handlerInfo.type);
+    this._handlerRows.delete(handlerInfo);
+
+    handlerInfo.remove();
+  },
+
+  _getIconURLForHandlerApp(aHandlerApp) {
+    if (aHandlerApp instanceof Ci.nsILocalHandlerApp) {
+      return this._getIconURLForFile(aHandlerApp.executable);
+    }
+
+    if (aHandlerApp instanceof Ci.nsIWebHandlerApp) {
+      return this._getIconURLForWebApp(aHandlerApp.uriTemplate);
+    }
+
+    if (aHandlerApp instanceof Ci.nsIWebContentHandlerInfo) {
+      return this._getIconURLForWebApp(aHandlerApp.uri);
+    }
+
+    // We know nothing about other kinds of handler apps.
+    return "";
+  },
+
+  _getIconURLForFile(aFile) {
+    let urlSpec = Services.io
+      .getProtocolHandler("file")
+      .QueryInterface(Ci.nsIFileProtocolHandler)
+      .getURLSpecFromActualFile(aFile);
+
+    return "moz-icon://" + urlSpec + "?size=16";
+  },
+
+  _getIconURLForWebApp(aWebAppURITemplate) {
+    var uri = Services.io.newURI(aWebAppURITemplate);
+
+    // Unfortunately we can't use the favicon service to get the favicon,
+    // because the service looks in the annotations table for a record with
+    // the exact URL we give it, and users won't have such records for URLs
+    // they don't visit, and users won't visit the web app's URL template,
+    // they'll only visit URLs derived from that template (i.e. with %s
+    // in the template replaced by the URL of the content being handled).
+
+    if (/^https?/.test(uri.scheme)) {
+      return uri.prePath + "/favicon.ico";
+    }
+
+    return /^https?/.test(uri.scheme) ? uri.resolve("/favicon.ico") : "";
+  },
+
+  destroy() {
+    window.removeEventListener("unload", this);
+
+    Services.obs.removeObserver(this, AUTO_UPDATE_CHANGED_TOPIC);
+    Services.prefs.removeObserver("mailnews.tags.", this);
+  },
+
+  // nsISupports
+
+  QueryInterface: ChromeUtils.generateQI(["nsIObserver"]),
+
+  // nsIObserver
+
+  async observe(subject, topic, data) {
+    if (topic == AUTO_UPDATE_CHANGED_TOPIC) {
+      if (data != "true" && data != "false") {
+        throw new Error(`Invalid value for app.update.auto ${data}`);
+      }
+      document.getElementById("updateRadioGroup").value = data;
+    } else if (topic == "nsPref:changed" && data.startsWith("mailnews.tags.")) {
+      let selIndex = this.mTagListBox.selectedIndex;
+      this.mTagListBox.replaceChildren();
+      this.buildTagList();
+      let numItemsInListBox = this.mTagListBox.getRowCount();
+      this.mTagListBox.selectedIndex =
+        selIndex < numItemsInListBox ? selIndex : numItemsInListBox - 1;
+      if (data.endsWith(".color") && Services.prefs.prefHasUserValue(data)) {
+        let key = data.replace(/^mailnews\.tags\./, "").replace(/\.color$/, "");
+        let color = Services.prefs.getCharPref(`mailnews.tags.${key}.color`);
+        // Add to style sheet. We simply add the new color, the rule is added
+        // at the end and will overrule the previous rule.
+        TagUtils.addTagToAllDocumentSheets(key, color);
+      }
+    }
+  },
+
+  // EventListener
+
+  handleEvent(aEvent) {
+    if (aEvent.type == "unload") {
+      this.destroy();
+      if (AppConstants.MOZ_UPDATER) {
+        onUnload();
+      }
+    }
+  },
+};
+
+function getDisplayNameForFile(aFile) {
+  if (AppConstants.platform == "win") {
+    if (aFile instanceof Ci.nsILocalFileWin) {
+      try {
+        return aFile.getVersionInfoField("FileDescription");
+      } catch (ex) {
+        // fall through to the file name
+      }
+    }
+  } else if (AppConstants.platform == "macosx") {
+    if (aFile instanceof Ci.nsILocalFileMac) {
+      try {
+        return aFile.bundleDisplayName;
+      } catch (ex) {
+        // fall through to the file name
+      }
+    }
+  }
+
+  return aFile.leafName;
+}
+
+function getLocalHandlerApp(aFile) {
+  var localHandlerApp = Cc[
+    "@mozilla.org/uriloader/local-handler-app;1"
+  ].createInstance(Ci.nsILocalHandlerApp);
+  localHandlerApp.name = getDisplayNameForFile(aFile);
+  localHandlerApp.executable = aFile;
+
+  return localHandlerApp;
+}
+
+// eslint-disable-next-line no-undef
+let gHandlerRowFragment = MozXULElement.parseXULToFragment(`
+  <html:tr>
+    <html:td class="typeCell">
+      <html:div class="typeLabel">
+        <html:img class="typeIcon" alt=""/>
+        <label class="typeDescription" crop="end"/>
+      </html:div>
+    </html:td>
+    <html:td class="actionCell">
+      <menulist class="actionsMenu" crop="end" selectedIndex="1">
+        <menupopup/>
+      </menulist>
+    </html:td>
+  </html:tr>
+`);
+
+/**
+ * This is associated to rows in the handlers table.
+ */
+class HandlerRow {
+  constructor(handlerInfoWrapper, onDeleteCallback) {
+    this.handlerInfoWrapper = handlerInfoWrapper;
+    this.previousSelectedItem = null;
+    this.deleteCallback = onDeleteCallback;
+  }
+
+  constructNodeAndAppend(tbody, id) {
+    tbody.appendChild(document.importNode(gHandlerRowFragment, true));
+    this.node = tbody.lastChild;
+
+    this.menu = this.node.querySelector(".actionsMenu");
+    id = `action-menu-${id}`;
+    this.menu.setAttribute("id", id);
+    this.menu.addEventListener("command", event =>
+      this.onSelectAction(event.originalTarget)
+    );
+
+    let typeDescription = this.node.querySelector(".typeDescription");
+    typeDescription.setAttribute(
+      "value",
+      this.handlerInfoWrapper.typeDescription
+    );
+    // NOTE: Control only works for a XUL <label>. Using a HTML <label> and the
+    // corresponding "for" attribute would not currently work with the XUL
+    // <menulist> because a XUL <menulist> is technically not a labelable
+    // element, as required for the html:label "for" attribute.
+    typeDescription.setAttribute("control", id);
+    // Spoof the HTML label "for" attribute focus behaviour on the whole cell.
+    this.node
+      .querySelector(".typeCell")
+      .addEventListener("click", () => this.menu.focus());
+
+    this.node
+      .querySelector(".typeIcon")
+      .setAttribute("src", this.handlerInfoWrapper.smallIcon);
+
+    this.rebuildActionsMenu();
+  }
+
+  rebuildActionsMenu() {
+    let menu = this.menu;
+    let menuPopup = menu.menupopup;
+    let handlerInfo = this.handlerInfoWrapper;
+
+    // Clear out existing items.
+    while (menuPopup.hasChildNodes()) {
+      menuPopup.removeChild(menuPopup.lastChild);
+    }
+
+    let internalMenuItem;
+    // Add the "Preview in Thunderbird" option for optional internal handlers.
+    if (handlerInfo instanceof InternalHandlerInfoWrapper) {
+      internalMenuItem = document.createXULElement("menuitem");
+      internalMenuItem.setAttribute(
+        "action",
+        Ci.nsIHandlerInfo.handleInternally
+      );
+      let label = gGeneralPane._prefsBundle.getFormattedString("previewInApp", [
+        gGeneralPane._brandShortName,
+      ]);
+      internalMenuItem.setAttribute("label", label);
+      internalMenuItem.setAttribute("tooltiptext", label);
+      internalMenuItem.setAttribute(
+        "image",
+        "chrome://messenger/skin/preferences/alwaysAsk.png"
+      );
+      menuPopup.appendChild(internalMenuItem);
+    }
+
+    let askMenuItem = document.createXULElement("menuitem");
+    askMenuItem.setAttribute("alwaysAsk", "true");
+    {
+      let label = gGeneralPane._prefsBundle.getString("alwaysAsk");
+      askMenuItem.setAttribute("label", label);
+      askMenuItem.setAttribute("tooltiptext", label);
+      askMenuItem.setAttribute(
+        "image",
+        "chrome://messenger/skin/preferences/alwaysAsk.png"
+      );
+      menuPopup.appendChild(askMenuItem);
+    }
+
+    // Create a menu item for saving to disk.
+    // Note: this option isn't available to protocol types, since we don't know
+    // what it means to save a URL having a certain scheme to disk.
+    let saveMenuItem;
+    if (handlerInfo.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo) {
+      saveMenuItem = document.createXULElement("menuitem");
+      saveMenuItem.setAttribute("action", Ci.nsIHandlerInfo.saveToDisk);
+      let label = gGeneralPane._prefsBundle.getString("saveFile");
+      saveMenuItem.setAttribute("label", label);
+      saveMenuItem.setAttribute("tooltiptext", label);
+      saveMenuItem.setAttribute(
+        "image",
+        "chrome://messenger/skin/preferences/saveFile.png"
+      );
+      menuPopup.appendChild(saveMenuItem);
+    }
+
+    // Add a separator to distinguish these items from the helper app items
+    // that follow them.
+    let menuItem = document.createXULElement("menuseparator");
+    menuPopup.appendChild(menuItem);
+
+    // Create a menu item for the OS default application, if any.
+    let defaultMenuItem;
+    if (handlerInfo.hasDefaultHandler) {
+      defaultMenuItem = document.createXULElement("menuitem");
+      defaultMenuItem.setAttribute(
+        "action",
+        Ci.nsIHandlerInfo.useSystemDefault
+      );
+      let label = gGeneralPane._prefsBundle.getFormattedString("useDefault", [
+        handlerInfo.defaultDescription,
+      ]);
+      defaultMenuItem.setAttribute("label", label);
+      defaultMenuItem.setAttribute(
+        "tooltiptext",
+        handlerInfo.defaultDescription
+      );
+      defaultMenuItem.setAttribute(
+        "image",
+        handlerInfo.iconURLForSystemDefault
+      );
+
+      menuPopup.appendChild(defaultMenuItem);
+    }
+
+    // Create menu items for possible handlers.
+    let preferredApp = handlerInfo.preferredApplicationHandler;
+    let possibleAppMenuItems = [];
+    for (let possibleApp of handlerInfo.possibleApplicationHandlers.enumerate()) {
+      if (!gGeneralPane.isValidHandlerApp(possibleApp)) {
+        continue;
+      }
+
+      let menuItem = document.createXULElement("menuitem");
+      menuItem.setAttribute("action", Ci.nsIHandlerInfo.useHelperApp);
+      let label;
+      if (possibleApp instanceof Ci.nsILocalHandlerApp) {
+        label = getDisplayNameForFile(possibleApp.executable);
+      } else {
+        label = possibleApp.name;
+      }
+      label = gGeneralPane._prefsBundle.getFormattedString("useApp", [label]);
+      menuItem.setAttribute("label", label);
+      menuItem.setAttribute("tooltiptext", label);
+      menuItem.setAttribute(
+        "image",
+        gGeneralPane._getIconURLForHandlerApp(possibleApp)
+      );
+
+      // Attach the handler app object to the menu item so we can use it
+      // to make changes to the datastore when the user selects the item.
+      menuItem.handlerApp = possibleApp;
+
+      menuPopup.appendChild(menuItem);
+      possibleAppMenuItems.push(menuItem);
+    }
+
+    // Create a menu item for selecting a local application.
+    let createItem = true;
+    if (AppConstants.platform == "win") {
+      // On Windows, selecting an application to open another application
+      // would be meaningless so we special case executables.
+      let executableType = Cc["@mozilla.org/mime;1"]
+        .getService(Ci.nsIMIMEService)
+        .getTypeFromExtension("exe");
+      if (handlerInfo.type == executableType) {
+        createItem = false;
+      }
+    }
+
+    if (createItem) {
+      let menuItem = document.createXULElement("menuitem");
+      menuItem.addEventListener("command", this.chooseApp.bind(this));
+      let label = gGeneralPane._prefsBundle.getString("useOtherApp");
+      menuItem.setAttribute("label", label);
+      menuItem.setAttribute("tooltiptext", label);
+      menuPopup.appendChild(menuItem);
+    }
+
+    // Create a menu item for managing applications.
+    if (possibleAppMenuItems.length) {
+      let menuItem = document.createXULElement("menuseparator");
+      menuPopup.appendChild(menuItem);
+      menuItem = document.createXULElement("menuitem");
+      menuItem.addEventListener("command", this.manageApp.bind(this));
+      menuItem.setAttribute(
+        "label",
+        gGeneralPane._prefsBundle.getString("manageApp")
+      );
+      menuPopup.appendChild(menuItem);
+    }
+
+    menuItem = document.createXULElement("menuseparator");
+    menuPopup.appendChild(menuItem);
+    menuItem = document.createXULElement("menuitem");
+    menuItem.addEventListener("command", this.confirmDelete.bind(this));
+    menuItem.setAttribute(
+      "label",
+      gGeneralPane._prefsBundle.getString("delete")
+    );
+    menuPopup.appendChild(menuItem);
+
+    // Select the item corresponding to the preferred action.  If the always
+    // ask flag is set, it overrides the preferred action.  Otherwise we pick
+    // the item identified by the preferred action (when the preferred action
+    // is to use a helper app, we have to pick the specific helper app item).
+    if (handlerInfo.alwaysAskBeforeHandling) {
+      menu.selectedItem = askMenuItem;
+    } else {
+      switch (handlerInfo.preferredAction) {
+        case Ci.nsIHandlerInfo.handleInternally:
+          if (internalMenuItem) {
+            menu.selectedItem = internalMenuItem;
+          } else {
+            console.error("No menu item defined to set!");
+          }
+          break;
+        case Ci.nsIHandlerInfo.useSystemDefault:
+          menu.selectedItem = defaultMenuItem;
+          break;
+        case Ci.nsIHandlerInfo.useHelperApp:
+          if (preferredApp) {
+            menu.selectedItem = possibleAppMenuItems.filter(v =>
+              v.handlerApp.equals(preferredApp)
+            )[0];
+          }
+          break;
+        case Ci.nsIHandlerInfo.saveToDisk:
+          menu.selectedItem = saveMenuItem;
+          break;
+      }
+    }
+    // menu.selectedItem may be null if the preferredAction is
+    // useSystemDefault, but handlerInfo.hasDefaultHandler returns false.
+    // For now, we'll just use the askMenuItem to avoid ugly exceptions.
+    this.previousSelectedItem = this.menu.selectedItem || askMenuItem;
+  }
+
+  manageApp(aEvent) {
+    // Don't let the normal "on select action" handler get this event,
+    // as we handle it specially ourselves.
+    aEvent.stopPropagation();
+
+    var handlerInfo = this.handlerInfoWrapper;
+
+    let onComplete = () => {
+      // Rebuild the actions menu so that we revert to the previous selection,
+      // or "Always ask" if the previous default application has been removed.
+      this.rebuildActionsMenu();
+    };
+
+    gSubDialog.open(
+      "chrome://messenger/content/preferences/applicationManager.xhtml",
+      { features: "resizable=no", closingCallback: onComplete },
+      handlerInfo
+    );
+  }
+
+  chooseApp(aEvent) {
+    // Don't let the normal "on select action" handler get this event,
+    // as we handle it specially ourselves.
+    aEvent.stopPropagation();
+
+    var handlerApp;
+    let onSelectionDone = function () {
+      // Rebuild the actions menu whether the user picked an app or canceled.
+      // If they picked an app, we want to add the app to the menu and select it.
+      // If they canceled, we want to go back to their previous selection.
+      this.rebuildActionsMenu();
+
+      // If the user picked a new app from the menu, select it.
+      if (handlerApp) {
+        let menuItems = this.menu.menupopup.children;
+        for (let i = 0; i < menuItems.length; i++) {
+          let menuItem = menuItems[i];
+          if (menuItem.handlerApp && menuItem.handlerApp.equals(handlerApp)) {
+            this.menu.selectedIndex = i;
+            this.onSelectAction(menuItem);
+            break;
+          }
+        }
+      }
+    }.bind(this);
+
+    if (AppConstants.platform == "win") {
+      let params = {};
+      let handlerInfo = this.handlerInfoWrapper;
+
+      params.mimeInfo = handlerInfo.wrappedHandlerInfo;
+
+      params.title = gGeneralPane._prefsBundle.getString("fpTitleChooseApp");
+      params.description = handlerInfo.description;
+      params.filename = null;
+      params.handlerApp = null;
+
+      let onAppSelected = () => {
+        if (gGeneralPane.isValidHandlerApp(params.handlerApp)) {
+          handlerApp = params.handlerApp;
+
+          // Add the app to the type's list of possible handlers.
+          handlerInfo.addPossibleApplicationHandler(handlerApp);
+        }
+        onSelectionDone();
+      };
+
+      gSubDialog.open(
+        "chrome://global/content/appPicker.xhtml",
+        { features: "resizable=no", closingCallback: onAppSelected },
+        params
+      );
+    } else {
+      let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker);
+      let winTitle = gGeneralPane._prefsBundle.getString("fpTitleChooseApp");
+      fp.init(window, winTitle, Ci.nsIFilePicker.modeOpen);
+      fp.appendFilters(Ci.nsIFilePicker.filterApps);
+
+      // Prompt the user to pick an app.  If they pick one, and it's a valid
+      // selection, then add it to the list of possible handlers.
+
+      fp.open(rv => {
+        if (
+          rv == Ci.nsIFilePicker.returnOK &&
+          fp.file &&
+          gGeneralPane._isValidHandlerExecutable(fp.file)
+        ) {
+          handlerApp = Cc[
+            "@mozilla.org/uriloader/local-handler-app;1"
+          ].createInstance(Ci.nsILocalHandlerApp);
+          handlerApp.name = getDisplayNameForFile(fp.file);
+          handlerApp.executable = fp.file;
+
+          // Add the app to the type's list of possible handlers.
+          let handlerInfo = this.handlerInfoWrapper;
+          handlerInfo.addPossibleApplicationHandler(handlerApp);
+        }
+        onSelectionDone();
+      });
+    }
+  }
+
+  confirmDelete(aEvent) {
+    aEvent.stopPropagation();
+    if (
+      Services.prompt.confirm(
+        null,
+        gGeneralPane._prefsBundle.getString("confirmDeleteTitle"),
+        gGeneralPane._prefsBundle.getString("confirmDeleteText")
+      )
+    ) {
+      // Deletes self.
+      this.deleteCallback(this);
+    } else {
+      // They hit cancel, so return them to the previously selected item.
+      this.menu.selectedItem = this.previousSelectedItem;
+    }
+  }
+
+  onSelectAction(aActionItem) {
+    this.previousSelectedItem = aActionItem;
+    this._storeAction(aActionItem);
+  }
+
+  _storeAction(aActionItem) {
+    var handlerInfo = this.handlerInfoWrapper;
+
+    if (aActionItem.hasAttribute("alwaysAsk")) {
+      handlerInfo.alwaysAskBeforeHandling = true;
+    } else if (aActionItem.hasAttribute("action")) {
+      let action = parseInt(aActionItem.getAttribute("action"));
+
+      // Set the preferred application handler.
+      // We leave the existing preferred app in the list when we set
+      // the preferred action to something other than useHelperApp so that
+      // legacy datastores that don't have the preferred app in the list
+      // of possible apps still include the preferred app in the list of apps
+      // the user can choose to handle the type.
+      if (action == Ci.nsIHandlerInfo.useHelperApp) {
+        handlerInfo.preferredApplicationHandler = aActionItem.handlerApp;
+      }
+
+      // Set the "always ask" flag.
+      handlerInfo.alwaysAskBeforeHandling = false;
+
+      // Set the preferred action.
+      handlerInfo.preferredAction = action;
+    }
+
+    handlerInfo.store();
+  }
+}
+
+/**
+ * This object wraps nsIHandlerInfo with some additional functionality
+ * the Applications prefpane needs to display and allow modification of
+ * the list of handled types.
+ *
+ * We create an instance of this wrapper for each entry we might display
+ * in the prefpane, and we compose the instances from various sources,
+ * including the handler service.
+ *
+ * We don't implement all the original nsIHandlerInfo functionality,
+ * just the stuff that the prefpane needs.
+ */
+class HandlerInfoWrapper {
+  constructor(type, handlerInfo) {
+    this.type = type;
+    this.wrappedHandlerInfo = handlerInfo;
+    this.disambiguateDescription = false;
+  }
+
+  get description() {
+    if (this.wrappedHandlerInfo.description) {
+      return this.wrappedHandlerInfo.description;
+    }
+
+    if (this.primaryExtension) {
+      var extension = this.primaryExtension.toUpperCase();
+      return document
+        .getElementById("bundlePreferences")
+        .getFormattedString("fileEnding", [extension]);
+    }
+    return this.type;
+  }
+
+  /**
+   * Describe, in a human-readable fashion, the type represented by the given
+   * handler info object.  Normally this is just the description, but if more
+   * than one object presents the same description, "disambiguateDescription"
+   * is set and we annotate the duplicate descriptions with the type itself
+   * to help users distinguish between those types.
+   */
+  get typeDescription() {
+    if (this.disambiguateDescription) {
+      return gGeneralPane._prefsBundle.getFormattedString(
+        "typeDetailsWithTypeAndExt",
+        [this.description, this.type]
+      );
+    }
+
+    return this.description;
+  }
+
+  /**
+   * Describe, in a human-readable fashion, the preferred action to take on
+   * the type represented by the given handler info object.
+   */
+  get actionDescription() {
+    // alwaysAskBeforeHandling overrides the preferred action, so if that flag
+    // is set, then describe that behavior instead.  For most types, this is
+    // the "alwaysAsk" string, but for the feed type we show something special.
+    if (this.alwaysAskBeforeHandling) {
+      return gGeneralPane._prefsBundle.getString("alwaysAsk");
+    }
+
+    switch (this.preferredAction) {
+      case Ci.nsIHandlerInfo.saveToDisk:
+        return gGeneralPane._prefsBundle.getString("saveFile");
+
+      case Ci.nsIHandlerInfo.useHelperApp:
+        var preferredApp = this.preferredApplicationHandler;
+        var name;
+        if (preferredApp instanceof Ci.nsILocalHandlerApp) {
+          name = getDisplayNameForFile(preferredApp.executable);
+        } else {
+          name = preferredApp.name;
+        }
+        return gGeneralPane._prefsBundle.getFormattedString("useApp", [name]);
+
+      case Ci.nsIHandlerInfo.handleInternally:
+        if (this instanceof InternalHandlerInfoWrapper) {
+          return gGeneralPane._prefsBundle.getFormattedString("previewInApp", [
+            gGeneralPane._brandShortName,
+          ]);
+        }
+
+        // For other types, handleInternally looks like either useHelperApp
+        // or useSystemDefault depending on whether or not there's a preferred
+        // handler app.
+        if (gGeneralPane.isValidHandlerApp(this.preferredApplicationHandler)) {
+          return this.preferredApplicationHandler.name;
+        }
+
+        return this.defaultDescription;
+
+      // XXX Why don't we say the app will handle the type internally?
+      // Is it because the app can't actually do that?  But if that's true,
+      // then why would a preferredAction ever get set to this value
+      // in the first place?
+
+      case Ci.nsIHandlerInfo.useSystemDefault:
+        return gGeneralPane._prefsBundle.getFormattedString("useDefault", [
+          this.defaultDescription,
+        ]);
+
+      default:
+        throw new Error(`Unexpected preferredAction: ${this.preferredAction}`);
+    }
+  }
+
+  get actionIconClass() {
+    if (this.alwaysAskBeforeHandling) {
+      return "ask";
+    }
+
+    switch (this.preferredAction) {
+      case Ci.nsIHandlerInfo.saveToDisk:
+        return "save";
+
+      case Ci.nsIHandlerInfo.handleInternally:
+        if (this instanceof InternalHandlerInfoWrapper) {
+          return "ask";
+        }
+    }
+
+    return "";
+  }
+
+  get actionIcon() {
+    switch (this.preferredAction) {
+      case Ci.nsIHandlerInfo.useSystemDefault:
+        return this.iconURLForSystemDefault;
+
+      case Ci.nsIHandlerInfo.useHelperApp:
+        let preferredApp = this.preferredApplicationHandler;
+        if (gGeneralPane.isValidHandlerApp(preferredApp)) {
+          return gGeneralPane._getIconURLForHandlerApp(preferredApp);
+        }
+      // This should never happen, but if preferredAction is set to some weird
+      // value, then fall back to the generic application icon.
+
+      // Explicit fall-through
+      default:
+        return ICON_URL_APP;
+    }
+  }
+
+  get iconURLForSystemDefault() {
+    // Handler info objects for MIME types on some OSes implement a property bag
+    // interface from which we can get an icon for the default app, so if we're
+    // dealing with a MIME type on one of those OSes, then try to get the icon.
+    if (
+      this.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo &&
+      this.wrappedHandlerInfo instanceof Ci.nsIPropertyBag
+    ) {
+      try {
+        let url = this.wrappedHandlerInfo.getProperty(
+          "defaultApplicationIconURL"
+        );
+        if (url) {
+          return url + "?size=16";
+        }
+      } catch (ex) {}
+    }
+
+    // If this isn't a MIME type object on an OS that supports retrieving
+    // the icon, or if we couldn't retrieve the icon for some other reason,
+    // then use a generic icon.
+    return ICON_URL_APP;
+  }
+
+  get preferredApplicationHandler() {
+    return this.wrappedHandlerInfo.preferredApplicationHandler;
+  }
+
+  set preferredApplicationHandler(aNewValue) {
+    this.wrappedHandlerInfo.preferredApplicationHandler = aNewValue;
+
+    // Make sure the preferred handler is in the set of possible handlers.
+    if (aNewValue) {
+      this.addPossibleApplicationHandler(aNewValue);
+    }
+  }
+
+  get possibleApplicationHandlers() {
+    return this.wrappedHandlerInfo.possibleApplicationHandlers;
+  }
+
+  addPossibleApplicationHandler(aNewHandler) {
+    for (let possibleApp of this.possibleApplicationHandlers.enumerate()) {
+      if (possibleApp.equals(aNewHandler)) {
+        return;
+      }
+    }
+    this.possibleApplicationHandlers.appendElement(aNewHandler);
+  }
+
+  removePossibleApplicationHandler(aHandler) {
+    var defaultApp = this.preferredApplicationHandler;
+    if (defaultApp && aHandler.equals(defaultApp)) {
+      // If the app we remove was the default app, we must make sure
+      // it won't be used anymore
+      this.alwaysAskBeforeHandling = true;
+      this.preferredApplicationHandler = null;
+    }
+
+    var handlers = this.possibleApplicationHandlers;
+    for (var i = 0; i < handlers.length; ++i) {
+      var handler = handlers.queryElementAt(i, Ci.nsIHandlerApp);
+      if (handler.equals(aHandler)) {
+        handlers.removeElementAt(i);
+        break;
+      }
+    }
+  }
+
+  get hasDefaultHandler() {
+    return this.wrappedHandlerInfo.hasDefaultHandler;
+  }
+
+  get defaultDescription() {
+    return this.wrappedHandlerInfo.defaultDescription;
+  }
+
+  // What to do with content of this type.
+  get preferredAction() {
+    // If the action is to use a helper app, but we don't have a preferred
+    // handler app, then switch to using the system default, if any; otherwise
+    // fall back to saving to disk, which is the default action in nsMIMEInfo.
+    // Note: "save to disk" is an invalid value for protocol info objects,
+    // but the alwaysAskBeforeHandling getter will detect that situation
+    // and always return true in that case to override this invalid value.
+    if (
+      this.wrappedHandlerInfo.preferredAction ==
+        Ci.nsIHandlerInfo.useHelperApp &&
+      !gGeneralPane.isValidHandlerApp(this.preferredApplicationHandler)
+    ) {
+      if (this.wrappedHandlerInfo.hasDefaultHandler) {
+        return Ci.nsIHandlerInfo.useSystemDefault;
+      }
+      return Ci.nsIHandlerInfo.saveToDisk;
+    }
+
+    return this.wrappedHandlerInfo.preferredAction;
+  }
+
+  set preferredAction(aNewValue) {
+    this.wrappedHandlerInfo.preferredAction = aNewValue;
+  }
+
+  get alwaysAskBeforeHandling() {
+    // If this is a protocol type and the preferred action is "save to disk",
+    // which is invalid for such types, then return true here to override that
+    // action.  This could happen when the preferred action is to use a helper
+    // app, but the preferredApplicationHandler is invalid, and there isn't
+    // a default handler, so the preferredAction getter returns save to disk
+    // instead.
+    if (
+      !(this.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo) &&
+      this.preferredAction == Ci.nsIHandlerInfo.saveToDisk
+    ) {
+      return true;
+    }
+
+    return this.wrappedHandlerInfo.alwaysAskBeforeHandling;
+  }
+
+  set alwaysAskBeforeHandling(aNewValue) {
+    this.wrappedHandlerInfo.alwaysAskBeforeHandling = aNewValue;
+  }
+
+  // The primary file extension associated with this type, if any.
+  get primaryExtension() {
+    try {
+      if (
+        this.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo &&
+        this.wrappedHandlerInfo.primaryExtension
+      ) {
+        return this.wrappedHandlerInfo.primaryExtension;
+      }
+    } catch (ex) {}
+
+    return null;
+  }
+
+  // -------
+  // Storage
+
+  store() {
+    gHandlerService.store(this.wrappedHandlerInfo);
+  }
+
+  remove() {
+    gHandlerService.remove(this.wrappedHandlerInfo);
+  }
+
+  // -----
+  // Icons
+
+  get smallIcon() {
+    return this._getIcon(16);
+  }
+
+  get largeIcon() {
+    return this._getIcon(32);
+  }
+
+  _getIcon(aSize) {
+    if (this.primaryExtension) {
+      return "moz-icon://goat." + this.primaryExtension + "?size=" + aSize;
+    }
+
+    if (this.wrappedHandlerInfo instanceof Ci.nsIMIMEInfo) {
+      return "moz-icon://goat?size=" + aSize + "&contentType=" + this.type;
+    }
+
+    // FIXME: consider returning some generic icon when we can't get a URL for
+    // one (for example in the case of protocol schemes).  Filed as bug 395141.
+    return null;
+  }
+}
+
+/**
+ * InternalHandlerInfoWrapper provides a basic mechanism to create an internal
+ * mime type handler that can be enabled/disabled in the applications preference
+ * menu.
+ */
+class InternalHandlerInfoWrapper extends HandlerInfoWrapper {
+  constructor(mimeType) {
+    super(mimeType, gMIMEService.getFromTypeAndExtension(mimeType, null));
+  }
+
+  // Override store so we so we can notify any code listening for registration
+  // or unregistration of this handler.
+  store() {
+    super.store();
+  }
+
+  get enabled() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  }
+
+  get description() {
+    return gGeneralPane._prefsBundle.getString(this._appPrefLabel);
+  }
+}
+
+class PDFHandlerInfoWrapper extends InternalHandlerInfoWrapper {
+  constructor() {
+    super(TYPE_PDF);
+  }
+
+  get _appPrefLabel() {
+    return "applications-type-pdf";
+  }
+
+  get enabled() {
+    return !Services.prefs.getBoolPref(PREF_PDFJS_DISABLED);
+  }
+}
+
+function addTagCallback(aName, aColor) {
+  MailServices.tags.addTag(aName, aColor, "");
+
+  // Add to style sheet.
+  let key = MailServices.tags.getKeyForTag(aName);
+  let tagListBox = document.getElementById("tagList");
+  let item = tagListBox.querySelector(`richlistitem[value=${key}]`);
+  tagListBox.ensureElementIsVisible(item);
+  tagListBox.selectItem(item);
+  tagListBox.focus();
+  return true;
+}
+
+Preferences.get("mailnews.start_page.enabled").on(
+  "change",
+  gGeneralPane.updateStartPage
+);
+Preferences.get("font.language.group").on("change", gGeneralPane._rebuildFonts);
+Preferences.get("mailnews.mark_message_read.auto").on(
+  "change",
+  gGeneralPane.updateMarkAsReadOptions
+);
+Preferences.get("mailnews.mark_message_read.delay").on(
+  "change",
+  gGeneralPane.updateMarkAsReadTextbox
+);
+Preferences.get("mail.prompt_purge_threshhold").on(
+  "change",
+  gGeneralPane.updateCompactOptions
+);
+Preferences.get("layers.acceleration.disabled").on(
+  "change",
+  gGeneralPane.updateHardwareAcceleration
+);
+if (AppConstants.platform != "macosx") {
+  Preferences.get("mail.biff.show_alert").on(
+    "change",
+    gGeneralPane.updateShowAlert
+  );
+}