tor-browser

home.js (34076B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

/* import-globals-from extensionControlled.js */
/* import-globals-from preferences.js */
/* import-globals-from main.js */

// HOME PAGE

ChromeUtils.defineESModuleGetters(this, {
 ExtensionUtils: "resource://gre/modules/ExtensionUtils.sys.mjs",
});

/*
* Preferences:
*
* browser.startup.homepage
* - the user's home page, as a string; if the home page is a set of tabs,
*   this will be those URLs separated by the pipe character "|"
* browser.newtabpage.enabled
* - determines that is shown on the user's new tab page.
*   true = Activity Stream is shown,
*   false = about:blank is shown
*/

const DEFAULT_HOMEPAGE_URL = "about:home";
const BLANK_HOMEPAGE_URL = "chrome://browser/content/blanktab.html";

Preferences.addAll([
 { id: "browser.startup.homepage", type: "string" },
 { id: "pref.browser.homepage.disable_button.current_page", type: "bool" },
 { id: "pref.browser.homepage.disable_button.bookmark_page", type: "bool" },
 {
   id: "pref.browser.homepage.disable_button.restore_default",
   type: "bool",
 },
 { id: "browser.newtabpage.enabled", type: "bool" },
]);

if (Services.prefs.getBoolPref("browser.settings-redesign.enabled")) {
 // Homepage / New Windows
 Preferences.addSetting(
   /** @type {{ useCustomHomepage: boolean } & SettingConfig } */ ({
     id: "homepageNewWindows",
     pref: "browser.startup.homepage",
     useCustomHomepage: false,
     get(prefVal) {
       if (this.useCustomHomepage) {
         return "custom";
       }
       switch (prefVal) {
         case DEFAULT_HOMEPAGE_URL:
           return "home";
         case BLANK_HOMEPAGE_URL:
           return "blank";
         // Bug 1969951 - Custom value can be any string so leaving it as default value to catch
         // non-default/blank entires.
         default:
           return "custom";
       }
     },
     set(inputVal, _, setting) {
       let wasCustomHomepage = this.useCustomHomepage;
       this.useCustomHomepage = inputVal == "custom";
       if (wasCustomHomepage != this.useCustomHomepage) {
         setting.onChange();
       }
       switch (inputVal) {
         case "home":
           return DEFAULT_HOMEPAGE_URL;
         case "blank":
           return BLANK_HOMEPAGE_URL;
         case "custom":
           // Bug 1969951 - Add values set in subpage here
           return setting.pref.value;
         default:
           throw new Error("No handler for this value");
       }
     },
   })
 );

 // Homepage / Choose Custom Homepage URL Button
 Preferences.addSetting({
   id: "homepageGoToCustomHomepageUrlPanel",
   deps: ["homepageNewWindows"],
   visible: ({ homepageNewWindows }) => {
     return homepageNewWindows.value == "custom";
   },
   onUserClick: () => {
     // Bug 1969951 - Navigate to Custom Homepage Subpage
   },
 });

 // Homepage / New Tabs
 Preferences.addSetting({
   id: "homepageNewTabs",
   pref: "browser.newtabpage.enabled",
   get(prefVal) {
     return prefVal.toString();
   },
   set(inputVal) {
     return inputVal === "true";
   },
 });

 // Homepage / Restore Defaults button
 Preferences.addSetting({
   id: "homepageRestoreDefaults",
   pref: "pref.browser.homepage.disable_button.restore_default",
   deps: ["homepageNewWindows", "homepageNewTabs"],
   disabled: ({ homepageNewWindows, homepageNewTabs }) => {
     return (
       homepageNewWindows.value === "home" && homepageNewTabs.value === "true"
     );
   },
   onUserClick: (e, { homepageNewWindows, homepageNewTabs }) => {
     e.preventDefault();

     // Bug 1969951 - This is temporary until the custom URL subpage is implemented.
     // Once users can set custom URLs in the subpage, this will properly reset those values.
     homepageNewWindows.value = "home";
     homepageNewTabs.value = "true";
   },
 });
}

const HOMEPAGE_OVERRIDE_KEY = "homepage_override";
const URL_OVERRIDES_TYPE = "url_overrides";
const NEW_TAB_KEY = "newTabURL";

// New Prefs UI: we need to check for this setting before registering prefs
// so that old-style prefs continue working
if (Services.prefs.getBoolPref("browser.settings-redesign.enabled")) {
 Preferences.addAll([
   { id: "browser.newtabpage.activity-stream.showSearch", type: "bool" },
   {
     id: "browser.newtabpage.activity-stream.system.showWeather",
     type: "bool",
   },
   { id: "browser.newtabpage.activity-stream.showWeather", type: "bool" },
   {
     id: "browser.newtabpage.activity-stream.widgets.system.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.widgets.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.widgets.system.lists.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.widgets.lists.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.widgets.system.focusTimer.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.widgets.focusTimer.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.feeds.topsites",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.topSitesRows",
     type: "int",
   },
   {
     id: "browser.newtabpage.activity-stream.feeds.system.topstories",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.feeds.section.topstories",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.discoverystream.sections.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.discoverystream.topicLabels.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.discoverystream.sections.personalization.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.discoverystream.sections.customizeMenuPanel.enabled",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.showSponsoredCheckboxes",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.showSponsoredTopSites",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.showSponsored",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.feeds.section.highlights",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.section.highlights.rows",
     type: "int",
   },
   {
     id: "browser.newtabpage.activity-stream.section.highlights.includeVisited",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.section.highlights.includeBookmarks",
     type: "bool",
   },
   {
     id: "browser.newtabpage.activity-stream.section.highlights.includeDownloads",
     type: "bool",
   },
 ]);

 // Search
 Preferences.addSetting({
   id: "webSearch",
   pref: "browser.newtabpage.activity-stream.showSearch",
 });

 // Weather
 Preferences.addSetting({
   id: "showWeather",
   pref: "browser.newtabpage.activity-stream.system.showWeather",
 });

 Preferences.addSetting({
   id: "weather",
   pref: "browser.newtabpage.activity-stream.showWeather",
   deps: ["showWeather"],
   visible: ({ showWeather }) => showWeather.value,
 });

 // Widgets: general
 Preferences.addSetting({
   id: "widgetsEnabled",
   pref: "browser.newtabpage.activity-stream.widgets.system.enabled",
 });

 Preferences.addSetting({
   id: "widgets",
   pref: "browser.newtabpage.activity-stream.widgets.enabled",
   deps: ["widgetsEnabled"],
   visible: ({ widgetsEnabled }) => widgetsEnabled.value,
 });

 // Widgets: lists
 Preferences.addSetting({
   id: "listsEnabled",
   pref: "browser.newtabpage.activity-stream.widgets.system.lists.enabled",
 });

 Preferences.addSetting({
   id: "lists",
   pref: "browser.newtabpage.activity-stream.widgets.lists.enabled",
   deps: ["listsEnabled"],
   visible: ({ listsEnabled }) => listsEnabled.value,
 });

 // Widgets: timer
 Preferences.addSetting({
   id: "timerEnabled",
   pref: "browser.newtabpage.activity-stream.widgets.system.focusTimer.enabled",
 });

 Preferences.addSetting({
   id: "timer",
   pref: "browser.newtabpage.activity-stream.widgets.focusTimer.enabled",
   deps: ["timerEnabled"],
   visible: ({ timerEnabled }) => timerEnabled.value,
 });

 // Shortcuts
 Preferences.addSetting({
   id: "shortcuts",
   pref: "browser.newtabpage.activity-stream.feeds.topsites",
 });
 Preferences.addSetting({
   id: "shortcutsRows",
   pref: "browser.newtabpage.activity-stream.topSitesRows",
 });

 // Stories
 Preferences.addSetting({
   id: "stories",
   pref: "browser.newtabpage.activity-stream.feeds.section.topstories",
 });
 Preferences.addSetting({
   id: "sectionsEnabled",
   pref: "browser.newtabpage.activity-stream.discoverystream.sections.enabled",
 });
 Preferences.addSetting({
   id: "topicLabelsEnabled",
   pref: "browser.newtabpage.activity-stream.discoverystream.topicLabels.enabled",
 });
 Preferences.addSetting({
   id: "sectionsPersonalizationEnabled",
   pref: "browser.newtabpage.activity-stream.discoverystream.sections.personalization.enabled",
 });
 Preferences.addSetting({
   id: "sectionsCustomizeMenuPanelEnabled",
   pref: "browser.newtabpage.activity-stream.discoverystream.sections.customizeMenuPanel.enabled",
 });
 Preferences.addSetting({
   id: "manageTopics",
   deps: [
     "sectionsEnabled",
     "topicLabelsEnabled",
     "sectionsPersonalizationEnabled",
     "sectionsCustomizeMenuPanelEnabled",
     "sectionTopstories",
   ],
   visible: ({
     sectionsEnabled,
     topicLabelsEnabled,
     sectionsPersonalizationEnabled,
     sectionsCustomizeMenuPanelEnabled,
     sectionTopstories,
   }) =>
     sectionsEnabled.value &&
     topicLabelsEnabled.value &&
     sectionsPersonalizationEnabled.value &&
     sectionsCustomizeMenuPanelEnabled.value &&
     sectionTopstories.value,
 });

 // Dependency prefs for sponsored stories visibility
 Preferences.addSetting({
   id: "systemTopstories",
   pref: "browser.newtabpage.activity-stream.feeds.system.topstories",
 });
 Preferences.addSetting({
   id: "sectionTopstories",
   pref: "browser.newtabpage.activity-stream.feeds.section.topstories",
 });

 // Support Firefox: sponsored content
 Preferences.addSetting({
   id: "supportFirefox",
   pref: "browser.newtabpage.activity-stream.showSponsoredCheckboxes",
   deps: ["sponsoredShortcuts", "sponsoredStories"],
   onUserChange(value, { sponsoredShortcuts, sponsoredStories }) {
     // When supportFirefox changes, automatically update child preferences to match
     sponsoredShortcuts.value = !!value;
     sponsoredStories.value = !!value;
   },
 });
 Preferences.addSetting({
   id: "topsitesEnabled",
   pref: "browser.newtabpage.activity-stream.feeds.topsites",
 });
 Preferences.addSetting({
   id: "sponsoredShortcuts",
   pref: "browser.newtabpage.activity-stream.showSponsoredTopSites",
   deps: ["topsitesEnabled"],
   disabled: ({ topsitesEnabled }) => !topsitesEnabled.value,
 });
 Preferences.addSetting({
   id: "sponsoredStories",
   pref: "browser.newtabpage.activity-stream.showSponsored",
   deps: ["systemTopstories", "sectionTopstories"],
   visible: ({ systemTopstories }) => !!systemTopstories.value,
   disabled: ({ sectionTopstories }) => !sectionTopstories.value,
 });
 Preferences.addSetting({
   id: "supportFirefoxPromo",
   deps: ["supportFirefox"],
 });

 // Recent activity
 Preferences.addSetting({
   id: "recentActivity",
   pref: "browser.newtabpage.activity-stream.feeds.section.highlights",
 });
 Preferences.addSetting({
   id: "recentActivityRows",
   pref: "browser.newtabpage.activity-stream.section.highlights.rows",
 });
 Preferences.addSetting({
   id: "recentActivityVisited",
   pref: "browser.newtabpage.activity-stream.section.highlights.includeVisited",
 });
 Preferences.addSetting({
   id: "recentActivityBookmarks",
   pref: "browser.newtabpage.activity-stream.section.highlights.includeBookmarks",
 });
 Preferences.addSetting({
   id: "recentActivityDownloads",
   pref: "browser.newtabpage.activity-stream.section.highlights.includeDownloads",
 });

 Preferences.addSetting({
   id: "chooseWallpaper",
 });
}

var gHomePane = {
 HOME_MODE_FIREFOX_HOME: "0",
 HOME_MODE_BLANK: "1",
 HOME_MODE_CUSTOM: "2",
 HOMEPAGE_PREF: "browser.startup.homepage",
 NEWTAB_ENABLED_PREF: "browser.newtabpage.enabled",
 ACTIVITY_STREAM_PREF_BRANCH: "browser.newtabpage.activity-stream.",

 get homePanePrefs() {
   return Preferences.getAll().filter(pref =>
     pref.id.includes(this.ACTIVITY_STREAM_PREF_BRANCH)
   );
 },

 get isPocketNewtabEnabled() {
   const value = Services.prefs.getStringPref(
     "browser.newtabpage.activity-stream.discoverystream.config",
     ""
   );
   if (value) {
     try {
       return JSON.parse(value).enabled;
     } catch (e) {
       console.error("Failed to parse Discovery Stream pref.");
     }
   }

   return false;
 },

 async syncToNewTabPref() {
   let menulist = document.getElementById("newTabMode");

   if (["0", "1"].includes(menulist.value)) {
     let newtabEnabledPref = Services.prefs.getBoolPref(
       this.NEWTAB_ENABLED_PREF,
       true
     );
     let newValue = menulist.value !== this.HOME_MODE_BLANK;
     // Only set this if the pref has changed, otherwise the pref change will trigger other listeners to repeat.
     if (newtabEnabledPref !== newValue) {
       Services.prefs.setBoolPref(this.NEWTAB_ENABLED_PREF, newValue);
     }
     let selectedAddon = ExtensionSettingsStore.getSetting(
       URL_OVERRIDES_TYPE,
       NEW_TAB_KEY
     );
     if (selectedAddon) {
       ExtensionSettingsStore.select(null, URL_OVERRIDES_TYPE, NEW_TAB_KEY);
     }
   } else {
     let addon = await AddonManager.getAddonByID(menulist.value);
     if (addon && addon.isActive) {
       ExtensionSettingsStore.select(
         addon.id,
         URL_OVERRIDES_TYPE,
         NEW_TAB_KEY
       );
     }
   }
 },

 async syncFromNewTabPref() {
   let menulist = document.getElementById("newTabMode");

   // If the new tab url was changed to about:blank or about:newtab
   if (
     AboutNewTab.newTabURL === "about:newtab" ||
     AboutNewTab.newTabURL === "about:blank" ||
     AboutNewTab.newTabURL === BLANK_HOMEPAGE_URL
   ) {
     let newtabEnabledPref = Services.prefs.getBoolPref(
       this.NEWTAB_ENABLED_PREF,
       true
     );
     let newValue = newtabEnabledPref
       ? this.HOME_MODE_FIREFOX_HOME
       : this.HOME_MODE_BLANK;
     if (newValue !== menulist.value) {
       menulist.value = newValue;
     }
     menulist.disabled = Preferences.get(this.NEWTAB_ENABLED_PREF).locked;
     // If change was triggered by installing an addon we need to update
     // the value of the menulist to be that addon.
   } else {
     let selectedAddon = ExtensionSettingsStore.getSetting(
       URL_OVERRIDES_TYPE,
       NEW_TAB_KEY
     );
     if (selectedAddon && menulist.value !== selectedAddon.id) {
       menulist.value = selectedAddon.id;
     }
   }
 },

 /**
  *  _updateMenuInterface: adds items to or removes them from the menulists
  *
  * @param {string} selectId Optional Id of the menulist to add or remove items from.
  *                          If not included this will update both home and newtab menus.
  */
 async _updateMenuInterface(selectId) {
   let selects;
   if (selectId) {
     selects = [document.getElementById(selectId)];
   } else {
     let newTabSelect = document.getElementById("newTabMode");
     let homeSelect = document.getElementById("homeMode");
     selects = [homeSelect, newTabSelect];
   }

   for (let select of selects) {
     // Remove addons from the menu popup which are no longer installed, or disabled.
     // let menuOptions = select.menupopup.childNodes;
     let menuOptions = Array.from(select.menupopup.childNodes);

     for (let option of menuOptions) {
       // If the value is not a number, assume it is an addon ID
       if (!/^\d+$/.test(option.value)) {
         let addon = await AddonManager.getAddonByID(option.value);
         if (option && (!addon || !addon.isActive)) {
           option.remove();
         }
       }
     }

     let extensionOptions;
     await ExtensionSettingsStore.initialize();
     if (select.id === "homeMode") {
       extensionOptions = ExtensionSettingsStore.getAllSettings(
         PREF_SETTING_TYPE,
         HOMEPAGE_OVERRIDE_KEY
       );
     } else {
       extensionOptions = ExtensionSettingsStore.getAllSettings(
         URL_OVERRIDES_TYPE,
         NEW_TAB_KEY
       );
     }
     let addons = await AddonManager.getAddonsByIDs(
       extensionOptions.map(a => a.id)
     );

     // Add addon options to the menu popups
     let menupopup = select.querySelector("menupopup");
     for (let addon of addons) {
       if (!addon || !addon.id || !addon.isActive) {
         continue;
       }
       let currentOption = select.querySelector(
         `[value="${CSS.escape(addon.id)}"]`
       );
       if (!currentOption) {
         let option = document.createXULElement("menuitem");
         option.value = addon.id;
         option.label = addon.name;
         menupopup.append(option);
       }
       let setting = extensionOptions.find(o => o.id == addon.id);
       if (
         (select.id === "homeMode" && setting.value == HomePage.get()) ||
         (select.id === "newTabMode" && setting.value == AboutNewTab.newTabURL)
       ) {
         select.value = addon.id;
       }
     }
   }
 },

 /**
  * watchNewTab: Listen for changes to the new tab url and enable/disable appropriate
  * areas of the UI.
  */
 watchNewTab() {
   let newTabObserver = () => {
     this.syncFromNewTabPref();
     this._updateMenuInterface("newTabMode");
   };
   Services.obs.addObserver(newTabObserver, "newtab-url-changed");
   window.addEventListener("unload", () => {
     Services.obs.removeObserver(newTabObserver, "newtab-url-changed");
   });
 },

 /**
  * watchHomePrefChange: Listen for preferences changes on the Home Tab in order to
  * show the appropriate home menu selection.
  */
 watchHomePrefChange() {
   const homePrefObserver = (subject, topic, data) => {
     // only update this UI if it is exactly the HOMEPAGE_PREF, not other prefs with the same root.
     if (data && data != this.HOMEPAGE_PREF) {
       return;
     }
     this._updateUseCurrentButton();
     this._renderCustomSettings();
     this._handleHomePageOverrides();
     this._updateMenuInterface("homeMode");
   };

   Services.prefs.addObserver(this.HOMEPAGE_PREF, homePrefObserver);
   window.addEventListener("unload", () => {
     Services.prefs.removeObserver(this.HOMEPAGE_PREF, homePrefObserver);
   });
 },

 /**
  * Listen extension changes on the New Tab and Home Tab
  * in order to update the UI and show or hide the Restore Defaults button.
  */
 watchExtensionPrefChange() {
   const extensionSettingChanged = (evt, setting) => {
     if (setting.key == "homepage_override" && setting.type == "prefs") {
       this._updateMenuInterface("homeMode");
     } else if (
       setting.key == "newTabURL" &&
       setting.type == "url_overrides"
     ) {
       this._updateMenuInterface("newTabMode");
     }
   };

   Management.on("extension-setting-changed", extensionSettingChanged);
   window.addEventListener("unload", () => {
     Management.off("extension-setting-changed", extensionSettingChanged);
   });
 },

 /**
  * Listen for all preferences changes on the Home Tab in order to show or
  * hide the Restore Defaults button.
  */
 watchHomeTabPrefChange() {
   const observer = () => this.toggleRestoreDefaultsBtn();
   Services.prefs.addObserver(this.ACTIVITY_STREAM_PREF_BRANCH, observer);
   Services.prefs.addObserver(this.HOMEPAGE_PREF, observer);
   Services.prefs.addObserver(this.NEWTAB_ENABLED_PREF, observer);

   window.addEventListener("unload", () => {
     Services.prefs.removeObserver(this.ACTIVITY_STREAM_PREF_BRANCH, observer);
     Services.prefs.removeObserver(this.HOMEPAGE_PREF, observer);
     Services.prefs.removeObserver(this.NEWTAB_ENABLED_PREF, observer);
   });
 },

 /**
  * _renderCustomSettings: Hides or shows the UI for setting a custom
  * homepage URL
  *
  * @param {obj} options
  * @param {bool} options.shouldShow Should the custom UI be shown?
  * @param {bool} options.isControlled Is an extension controlling the home page?
  */
 _renderCustomSettings(options = {}) {
   let { shouldShow, isControlled } = options;
   const customSettingsContainerEl = document.getElementById("customSettings");
   const customUrlEl = document.getElementById("homePageUrl");
   const homePage = HomePage.get();
   const isHomePageCustom =
     (!this._isHomePageDefaultValue() &&
       !this.isHomePageBlank() &&
       !isControlled) ||
     homePage.locked;

   if (typeof shouldShow === "undefined") {
     shouldShow = isHomePageCustom;
   }
   customSettingsContainerEl.hidden = !shouldShow;

   // We can't use isHomePageDefaultValue and isHomePageBlank here because we want to disregard the blank
   // possibility triggered by the browser.startup.page being 0.
   // We also skip when HomePage is locked because it might be locked to a default that isn't "about:home"
   // (and it makes existing tests happy).
   let newValue;
   if (
     this._isBlankPage(homePage) ||
     (HomePage.isDefault && !HomePage.locked)
   ) {
     newValue = "";
   } else {
     newValue = homePage;
   }
   if (customUrlEl.value !== newValue) {
     customUrlEl.value = newValue;
   }
 },

 /**
  * _isHomePageDefaultValue
  *
  * @returns {bool} Is the homepage set to the default pref value?
  */
 _isHomePageDefaultValue() {
   const startupPref = Preferences.get("browser.startup.page");
   return (
     startupPref.value !== gMainPane.STARTUP_PREF_BLANK && HomePage.isDefault
   );
 },

 /**
  * isHomePageBlank
  *
  * @returns {bool} Is the homepage set to about:blank?
  */
 isHomePageBlank() {
   const startupPref = Preferences.get("browser.startup.page");
   return (
     ["about:blank", BLANK_HOMEPAGE_URL, ""].includes(HomePage.get()) ||
     startupPref.value === gMainPane.STARTUP_PREF_BLANK
   );
 },

 /**
  * _isTabAboutPreferencesOrSettings: Is a given tab set to about:preferences or about:settings?
  *
  * @param {Element} aTab A tab element
  * @returns {bool} Is the linkedBrowser of aElement set to about:preferences or about:settings?
  */
 _isTabAboutPreferencesOrSettings(aTab) {
   return (
     aTab.linkedBrowser.currentURI.spec.startsWith("about:preferences") ||
     aTab.linkedBrowser.currentURI.spec.startsWith("about:settings")
   );
 },

 /**
  * _getTabsForHomePage
  *
  * @returns {Array} An array of current tabs
  */
 _getTabsForHomePage() {
   let tabs = [];
   let win = Services.wm.getMostRecentWindow("navigator:browser");

   // We should only include visible & non-pinned tabs
   if (
     win &&
     win.document.documentElement.getAttribute("windowtype") ===
       "navigator:browser"
   ) {
     tabs = win.gBrowser.visibleTabs.slice(win.gBrowser.pinnedTabCount);
     tabs = tabs.filter(tab => !this._isTabAboutPreferencesOrSettings(tab));
     // XXX: Bug 1441637 - Fix tabbrowser to report tab.closing before it blurs it
     tabs = tabs.filter(tab => !tab.closing);
   }

   return tabs;
 },

 _renderHomepageMode(controllingExtension) {
   const isDefault = this._isHomePageDefaultValue();
   const isBlank = this.isHomePageBlank();
   const el = document.getElementById("homeMode");
   let newValue;

   if (controllingExtension && controllingExtension.id) {
     newValue = controllingExtension.id;
   } else if (isBlank) {
     // For base-browser, we want to check isBlank first since the default page
     // is also the blank page, but we only have a menu option for
     // HOME_MODE_BLANK, rather than HOME_MODE_FIREFOX_HOME.
     // See tor-browser#41609.
     newValue = this.HOME_MODE_BLANK;
   } else if (isDefault) {
     newValue = this.HOME_MODE_FIREFOX_HOME;
   } else {
     newValue = this.HOME_MODE_CUSTOM;
   }
   if (el.value !== newValue) {
     el.value = newValue;
   }
 },

 _setInputDisabledStates(isControlled) {
   let tabCount = this._getTabsForHomePage().length;

   // Disable or enable the inputs based on if this is controlled by an extension.
   document
     .querySelectorAll(".check-home-page-controlled")
     .forEach(element => {
       let isDisabled;
       let pref =
         element.getAttribute("preference") ||
         element.getAttribute("data-preference-related");
       if (!pref) {
         throw new Error(
           `Element with id ${element.id} did not have preference or data-preference-related attribute defined.`
         );
       }

       if (pref === this.HOMEPAGE_PREF) {
         isDisabled = HomePage.locked;
       } else {
         isDisabled = Preferences.get(pref).locked || isControlled;
       }

       if (pref === "pref.browser.disable_button.current_page") {
         // Special case for current_page to disable it if tabCount is 0
         isDisabled = isDisabled || tabCount < 1;
       }

       element.disabled = isDisabled;
     });
 },

 async _handleHomePageOverrides() {
   let controllingExtension;
   if (HomePage.locked) {
     // Disable inputs if they are locked.
     this._renderCustomSettings();
     this._setInputDisabledStates(false);
   } else {
     if (ExtensionUtils.isExtensionUrl(HomePage.get())) {
       controllingExtension = await getControllingExtension(
         PREF_SETTING_TYPE,
         HOMEPAGE_OVERRIDE_KEY
       );
     }
     this._setInputDisabledStates();
     this._renderCustomSettings({
       isControlled: !!controllingExtension,
     });
   }
   this._renderHomepageMode(controllingExtension);
 },

 onMenuChange(event) {
   const { value } = event.target;
   const startupPref = Preferences.get("browser.startup.page");
   let selectedAddon = ExtensionSettingsStore.getSetting(
     PREF_SETTING_TYPE,
     HOMEPAGE_OVERRIDE_KEY
   );

   switch (value) {
     case this.HOME_MODE_FIREFOX_HOME:
       if (startupPref.value === gMainPane.STARTUP_PREF_BLANK) {
         startupPref.value = gMainPane.STARTUP_PREF_HOMEPAGE;
       }
       if (!HomePage.isDefault) {
         HomePage.reset();
       } else {
         this._renderCustomSettings({ shouldShow: false });
       }
       if (selectedAddon) {
         ExtensionSettingsStore.select(
           null,
           PREF_SETTING_TYPE,
           HOMEPAGE_OVERRIDE_KEY
         );
       }
       break;
     case this.HOME_MODE_BLANK:
       if (!this._isBlankPage(HomePage.get())) {
         HomePage.safeSet(BLANK_HOMEPAGE_URL);
       } else {
         this._renderCustomSettings({ shouldShow: false });
       }
       if (selectedAddon) {
         ExtensionSettingsStore.select(
           null,
           PREF_SETTING_TYPE,
           HOMEPAGE_OVERRIDE_KEY
         );
       }
       break;
     case this.HOME_MODE_CUSTOM:
       if (startupPref.value === gMainPane.STARTUP_PREF_BLANK) {
         Services.prefs.clearUserPref(startupPref.id);
       }
       if (HomePage.getDefault() != HomePage.getOriginalDefault()) {
         HomePage.clear();
       }
       this._renderCustomSettings({ shouldShow: true });
       if (selectedAddon) {
         ExtensionSettingsStore.select(
           null,
           PREF_SETTING_TYPE,
           HOMEPAGE_OVERRIDE_KEY
         );
       }
       break;
     // extensions will have a variety of values as their ID, so treat it as default
     default:
       AddonManager.getAddonByID(value).then(addon => {
         if (addon && addon.isActive) {
           ExtensionPreferencesManager.selectSetting(
             addon.id,
             HOMEPAGE_OVERRIDE_KEY
           );
         }
         this._renderCustomSettings({ shouldShow: false });
       });
   }
 },

 /**
  * Switches the "Use Current Page" button between its singular and plural
  * forms.
  */
 async _updateUseCurrentButton() {
   let useCurrent = document.getElementById("useCurrentBtn");
   let tabs = this._getTabsForHomePage();
   const tabCount = tabs.length;
   document.l10n.setAttributes(useCurrent, "use-current-pages", { tabCount });

   // If the homepage is controlled by an extension then you can't use this.
   if (
     await getControllingExtensionInfo(
       PREF_SETTING_TYPE,
       HOMEPAGE_OVERRIDE_KEY
     )
   ) {
     return;
   }

   // In this case, the button's disabled state is set by preferences.xml.
   let prefName = "pref.browser.homepage.disable_button.current_page";
   if (Preferences.get(prefName).locked) {
     return;
   }

   useCurrent.disabled = tabCount < 1;
 },

 /**
  * Sets the home page to the URL(s) of any currently opened tab(s),
  * updating about:preferences#home UI to reflect this.
  */
 setHomePageToCurrent() {
   let tabs = this._getTabsForHomePage();
   function getTabURI(t) {
     return t.linkedBrowser.currentURI.spec;
   }

   // FIXME Bug 244192: using dangerous "|" joiner!
   if (tabs.length) {
     HomePage.set(tabs.map(getTabURI).join("|")).catch(console.error);
   }
 },

 _setHomePageToBookmarkClosed(rv, aEvent) {
   if (aEvent.detail.button != "accept") {
     return;
   }
   if (rv.urls && rv.names) {
     // XXX still using dangerous "|" joiner!
     HomePage.set(rv.urls.join("|")).catch(console.error);
   }
 },

 /**
  * Displays a dialog in which the user can select a bookmark to use as home
  * page.  If the user selects a bookmark, that bookmark's name is displayed in
  * UI and the bookmark's address is stored to the home page preference.
  */
 setHomePageToBookmark() {
   const rv = { urls: null, names: null };
   gSubDialog.open(
     "chrome://browser/content/preferences/dialogs/selectBookmark.xhtml",
     {
       features: "resizable=yes, modal=yes",
       closingCallback: this._setHomePageToBookmarkClosed.bind(this, rv),
     },
     rv
   );
 },

 restoreDefaultHomePage() {
   HomePage.reset();
   this._handleHomePageOverrides();
   Services.prefs.clearUserPref(this.NEWTAB_ENABLED_PREF);
   AboutNewTab.resetNewTabURL();
 },

 onCustomHomePageChange(event) {
   const value = event.target.value || HomePage.getDefault();
   HomePage.set(value).catch(console.error);
 },

 /**
  * Check all Home Tab preferences for user set values.
  */
 _changedHomeTabDefaultPrefs() {
   // If Discovery Stream is enabled Firefox Home Content preference options are hidden
   const homeContentChanged =
     !this.isPocketNewtabEnabled &&
     this.homePanePrefs.some(pref => pref.hasUserValue);
   const newtabPref = Preferences.get(this.NEWTAB_ENABLED_PREF);
   const extensionControlled = Preferences.get(
     "browser.startup.homepage_override.extensionControlled"
   );

   return (
     homeContentChanged ||
     HomePage.overridden ||
     newtabPref.hasUserValue ||
     AboutNewTab.newTabURLOverridden ||
     extensionControlled
   );
 },

 _isBlankPage(url) {
   return url == "about:blank" || url == BLANK_HOMEPAGE_URL;
 },

 /**
  * Show the Restore Defaults button if any preference on the Home tab was
  * changed, or hide it otherwise.
  */
 toggleRestoreDefaultsBtn() {
   const btn = document.getElementById("restoreDefaultHomePageBtn");
   const prefChanged = this._changedHomeTabDefaultPrefs();
   if (prefChanged) {
     btn.style.removeProperty("visibility");
   } else {
     btn.style.visibility = "hidden";
   }
 },

 /**
  * Set all prefs on the Home tab back to their default values.
  */
 restoreDefaultPrefsForHome() {
   this.restoreDefaultHomePage();
   // If Discovery Stream is enabled Firefox Home Content preference options are hidden
   if (!this.isPocketNewtabEnabled) {
     this.homePanePrefs.forEach(pref => Services.prefs.clearUserPref(pref.id));
   }
 },

 init() {
   initSettingGroup("homepage");
   initSettingGroup("home");

   // Event Listeners
   document
     .getElementById("homePageUrl")
     .addEventListener("change", this.onCustomHomePageChange.bind(this));
   document
     .getElementById("useCurrentBtn")
     .addEventListener("command", this.setHomePageToCurrent.bind(this));
   document
     .getElementById("useBookmarkBtn")
     .addEventListener("command", this.setHomePageToBookmark.bind(this));
   document
     .getElementById("restoreDefaultHomePageBtn")
     .addEventListener("command", this.restoreDefaultPrefsForHome.bind(this));

   // Setup the add-on options for the new tab section before registering the
   // listener.
   this._updateMenuInterface();
   document
     .getElementById("newTabMode")
     .addEventListener("command", this.syncToNewTabPref.bind(this));
   document
     .getElementById("homeMode")
     .addEventListener("command", this.onMenuChange.bind(this));

   this._updateUseCurrentButton();
   this._handleHomePageOverrides();
   this.syncFromNewTabPref();
   window.addEventListener("focus", this._updateUseCurrentButton.bind(this));

   // Extension/override-related events
   this.watchNewTab();
   this.watchHomePrefChange();
   this.watchExtensionPrefChange();
   this.watchHomeTabPrefChange();
   // Notify observers that the UI is now ready
   Services.obs.notifyObservers(window, "home-pane-loaded");
 },
};