summaryrefslogtreecommitdiffstats
path: root/browser/modules/HomePage.jsm
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 17:32:43 +0000
commit6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch)
treea68f146d7fa01f0134297619fbe7e33db084e0aa /browser/modules/HomePage.jsm
parentInitial commit. (diff)
downloadthunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz
thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'browser/modules/HomePage.jsm')
-rw-r--r--browser/modules/HomePage.jsm359
1 files changed, 359 insertions, 0 deletions
diff --git a/browser/modules/HomePage.jsm b/browser/modules/HomePage.jsm
new file mode 100644
index 0000000000..3c4103f14f
--- /dev/null
+++ b/browser/modules/HomePage.jsm
@@ -0,0 +1,359 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["HomePage"];
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ CustomizableUI: "resource:///modules/CustomizableUI.sys.mjs",
+ ExtensionParent: "resource://gre/modules/ExtensionParent.sys.mjs",
+ ExtensionPreferencesManager:
+ "resource://gre/modules/ExtensionPreferencesManager.sys.mjs",
+ IgnoreLists: "resource://gre/modules/IgnoreLists.sys.mjs",
+ PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+});
+
+const kPrefName = "browser.startup.homepage";
+const kDefaultHomePage = "about:home";
+const kExtensionControllerPref =
+ "browser.startup.homepage_override.extensionControlled";
+const kHomePageIgnoreListId = "homepage-urls";
+const kWidgetId = "home-button";
+const kWidgetRemovedPref = "browser.engagement.home-button.has-removed";
+
+function getHomepagePref(useDefault) {
+ let homePage;
+ let prefs = Services.prefs;
+ if (useDefault) {
+ prefs = prefs.getDefaultBranch(null);
+ }
+ try {
+ // Historically, this was a localizable pref, but default Firefox builds
+ // don't use this.
+ // Distributions and local customizations might still use this, so let's
+ // keep it.
+ homePage = prefs.getComplexValue(kPrefName, Ci.nsIPrefLocalizedString).data;
+ } catch (ex) {}
+
+ if (!homePage) {
+ homePage = prefs.getStringPref(kPrefName);
+ }
+
+ // Apparently at some point users ended up with blank home pages somehow.
+ // If that happens, reset the pref and read it again.
+ if (!homePage && !useDefault) {
+ Services.prefs.clearUserPref(kPrefName);
+ homePage = getHomepagePref(true);
+ }
+
+ return homePage;
+}
+
+/**
+ * HomePage provides tools to keep track of the current homepage, and the
+ * applications's default homepage. It includes tools to insure that certain
+ * urls are ignored. As a result, all set/get requests for the homepage
+ * preferences should be routed through here.
+ */
+let HomePage = {
+ // This is an array of strings that should be matched against URLs to see
+ // if they should be ignored or not.
+ _ignoreList: [],
+
+ // A promise that is set when initialization starts and resolved when it
+ // completes.
+ _initializationPromise: null,
+
+ /**
+ * Used to initialise the ignore lists. This may be called later than
+ * the first call to get or set, which may cause a used to get an ignored
+ * homepage, but this is deemed acceptable, as we'll correct it once
+ * initialised.
+ */
+ async delayedStartup() {
+ if (this._initializationPromise) {
+ await this._initializationPromise;
+ return;
+ }
+
+ Services.telemetry.setEventRecordingEnabled("homepage", true);
+
+ // Now we have the values, listen for future updates.
+ this._ignoreListListener = this._handleIgnoreListUpdated.bind(this);
+
+ this._initializationPromise = lazy.IgnoreLists.getAndSubscribe(
+ this._ignoreListListener
+ );
+
+ this._addCustomizableUiListener();
+
+ const current = await this._initializationPromise;
+
+ await this._handleIgnoreListUpdated({ data: { current } });
+ },
+
+ /**
+ * Gets the homepage for the given window.
+ *
+ * @param {DOMWindow} [aWindow]
+ * The window associated with the get, used to check for private browsing
+ * mode. If not supplied, normal mode is assumed.
+ * @returns {string}
+ * Returns the home page value, this could be a single url, or a `|`
+ * separated list of URLs.
+ */
+ get(aWindow) {
+ let homePages = getHomepagePref();
+ if (
+ lazy.PrivateBrowsingUtils.permanentPrivateBrowsing ||
+ (aWindow && lazy.PrivateBrowsingUtils.isWindowPrivate(aWindow))
+ ) {
+ // If an extension controls the setting and does not have private
+ // browsing permission, use the default setting.
+ let extensionControlled = Services.prefs.getBoolPref(
+ kExtensionControllerPref,
+ false
+ );
+ let privateAllowed = Services.prefs.getBoolPref(
+ "browser.startup.homepage_override.privateAllowed",
+ false
+ );
+ // There is a potential on upgrade that the prefs are not set yet, so we double check
+ // for moz-extension.
+ if (
+ !privateAllowed &&
+ (extensionControlled || homePages.includes("moz-extension://"))
+ ) {
+ return this.getDefault();
+ }
+ }
+
+ if (homePages == "about:blank") {
+ homePages = "chrome://browser/content/blanktab.html";
+ }
+
+ return homePages;
+ },
+
+ /**
+ * @returns {string}
+ * Returns the application default homepage.
+ */
+ getDefault() {
+ return getHomepagePref(true);
+ },
+
+ /**
+ * @returns {string}
+ * Returns the original application homepage URL (not from prefs).
+ */
+ getOriginalDefault() {
+ return kDefaultHomePage;
+ },
+
+ /**
+ * @returns {boolean}
+ * Returns true if the homepage has been changed.
+ */
+ get overridden() {
+ return Services.prefs.prefHasUserValue(kPrefName);
+ },
+
+ /**
+ * @returns {boolean}
+ * Returns true if the homepage preference is locked.
+ */
+ get locked() {
+ return Services.prefs.prefIsLocked(kPrefName);
+ },
+
+ /**
+ * @returns {boolean}
+ * Returns true if the current homepage is the application default.
+ */
+ get isDefault() {
+ return HomePage.get() === kDefaultHomePage;
+ },
+
+ /**
+ * Sets the homepage preference to a new page.
+ *
+ * @param {string} value
+ * The new value to set the preference to. This could be a single url, or a
+ * `|` separated list of URLs.
+ */
+ async set(value) {
+ await this.delayedStartup();
+
+ if (await this.shouldIgnore(value)) {
+ console.error(
+ `Ignoring homepage setting for ${value} as it is on the ignore list.`
+ );
+ Services.telemetry.recordEvent(
+ "homepage",
+ "preference",
+ "ignore",
+ "set_blocked"
+ );
+ return false;
+ }
+ Services.prefs.setStringPref(kPrefName, value);
+ this._maybeAddHomeButtonToToolbar(value);
+ return true;
+ },
+
+ /**
+ * Sets the homepage preference to a new page. This is an synchronous version
+ * that should only be used when we know the source is safe as it bypasses the
+ * ignore list, e.g. when setting directly to about:blank or a value not
+ * supplied externally.
+ *
+ * @param {string} value
+ * The new value to set the preference to. This could be a single url, or a
+ * `|` separated list of URLs.
+ */
+ safeSet(value) {
+ Services.prefs.setStringPref(kPrefName, value);
+ },
+
+ /**
+ * Clears the homepage preference if it is not the default. Note that for
+ * policy/locking use, the default homepage might not be about:home after this.
+ */
+ clear() {
+ Services.prefs.clearUserPref(kPrefName);
+ },
+
+ /**
+ * Resets the homepage preference to be about:home.
+ */
+ reset() {
+ Services.prefs.setStringPref(kPrefName, kDefaultHomePage);
+ },
+
+ /**
+ * Determines if a url should be ignored according to the ignore list.
+ *
+ * @param {string} url
+ * A string that is the url or urls to be ignored.
+ * @returns {boolean}
+ * True if the url should be ignored.
+ */
+ async shouldIgnore(url) {
+ await this.delayedStartup();
+
+ const lowerURL = url.toLowerCase();
+ return this._ignoreList.some(code => lowerURL.includes(code.toLowerCase()));
+ },
+
+ /**
+ * Handles updates of the ignore list, checking the existing preference and
+ * correcting it as necessary.
+ *
+ * @param {Object} eventData
+ * The event data as received from RemoteSettings.
+ */
+ async _handleIgnoreListUpdated({ data: { current } }) {
+ for (const entry of current) {
+ if (entry.id == kHomePageIgnoreListId) {
+ this._ignoreList = [...entry.matches];
+ }
+ }
+
+ // Only check if we're overridden as we assume the default value is fine,
+ // or won't be changeable (e.g. enterprise policy).
+ if (this.overridden) {
+ let homePages = getHomepagePref().toLowerCase();
+ if (
+ this._ignoreList.some(code => homePages.includes(code.toLowerCase()))
+ ) {
+ if (Services.prefs.getBoolPref(kExtensionControllerPref, false)) {
+ if (Services.appinfo.inSafeMode) {
+ // Add-ons don't get started in safe mode, so just abort this.
+ // We'll get to remove them when we next start in normal mode.
+ return;
+ }
+ // getSetting does not need the module to be loaded.
+ const item = await lazy.ExtensionPreferencesManager.getSetting(
+ "homepage_override"
+ );
+ if (item && item.id) {
+ // During startup some modules may not be loaded yet, so we load
+ // the setting we need prior to removal.
+ await lazy.ExtensionParent.apiManager.asyncLoadModule(
+ "chrome_settings_overrides"
+ );
+ lazy.ExtensionPreferencesManager.removeSetting(
+ item.id,
+ "homepage_override"
+ ).catch(console.error);
+ } else {
+ // If we don't have a setting for it, we assume the pref has
+ // been incorrectly set somehow.
+ Services.prefs.clearUserPref(kExtensionControllerPref);
+ Services.prefs.clearUserPref(
+ "browser.startup.homepage_override.privateAllowed"
+ );
+ }
+ } else {
+ this.clear();
+ }
+ Services.telemetry.recordEvent(
+ "homepage",
+ "preference",
+ "ignore",
+ "saved_reset"
+ );
+ }
+ }
+ },
+
+ onWidgetRemoved(widgetId, area) {
+ if (widgetId == kWidgetId) {
+ Services.prefs.setBoolPref(kWidgetRemovedPref, true);
+ lazy.CustomizableUI.removeListener(this);
+ }
+ },
+
+ /**
+ * Add the home button to the toolbar if the user just set a custom homepage.
+ *
+ * This should only be done once, so we check HOME_BUTTON_REMOVED_PREF which
+ * gets set to true when the home button is removed from the toolbar.
+ *
+ * If the home button is already on the toolbar it won't be moved.
+ */
+ _maybeAddHomeButtonToToolbar(homePage) {
+ if (
+ homePage !== "about:home" &&
+ homePage !== "about:blank" &&
+ !Services.prefs.getBoolPref(kExtensionControllerPref, false) &&
+ !Services.prefs.getBoolPref(kWidgetRemovedPref, false) &&
+ !lazy.CustomizableUI.getWidget(kWidgetId).areaType
+ ) {
+ // Find a spot for the home button, ideally it will be in its default
+ // position beside the stop/refresh button.
+ // Work backwards from the URL bar since it can't be removed and put
+ // the button after the first non-spring we find.
+ let navbarPlacements = lazy.CustomizableUI.getWidgetIdsInArea("nav-bar");
+ let position = navbarPlacements.indexOf("urlbar-container");
+ for (let i = position - 1; i >= 0; i--) {
+ if (!navbarPlacements[i].startsWith("customizableui-special-spring")) {
+ position = i + 1;
+ break;
+ }
+ }
+ lazy.CustomizableUI.addWidgetToArea(kWidgetId, "nav-bar", position);
+ }
+ },
+
+ _addCustomizableUiListener() {
+ if (!Services.prefs.getBoolPref(kWidgetRemovedPref, false)) {
+ lazy.CustomizableUI.addListener(this);
+ }
+ },
+};