summaryrefslogtreecommitdiffstats
path: root/toolkit/components/search/SearchService.sys.mjs
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/search/SearchService.sys.mjs')
-rw-r--r--toolkit/components/search/SearchService.sys.mjs4068
1 files changed, 4068 insertions, 0 deletions
diff --git a/toolkit/components/search/SearchService.sys.mjs b/toolkit/components/search/SearchService.sys.mjs
new file mode 100644
index 0000000000..4e1a99671f
--- /dev/null
+++ b/toolkit/components/search/SearchService.sys.mjs
@@ -0,0 +1,4068 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* eslint no-shadow: error, mozilla/no-aArgs: error */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
+ AppProvidedSearchEngine:
+ "resource://gre/modules/AppProvidedSearchEngine.sys.mjs",
+ AddonSearchEngine: "resource://gre/modules/AddonSearchEngine.sys.mjs",
+ IgnoreLists: "resource://gre/modules/IgnoreLists.sys.mjs",
+ loadAndParseOpenSearchEngine:
+ "resource://gre/modules/OpenSearchLoader.sys.mjs",
+ NimbusFeatures: "resource://nimbus/ExperimentAPI.sys.mjs",
+ OpenSearchEngine: "resource://gre/modules/OpenSearchEngine.sys.mjs",
+ PolicySearchEngine: "resource://gre/modules/PolicySearchEngine.sys.mjs",
+ Region: "resource://gre/modules/Region.sys.mjs",
+ RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",
+ SearchEngine: "resource://gre/modules/SearchEngine.sys.mjs",
+ SearchEngineSelector: "resource://gre/modules/SearchEngineSelector.sys.mjs",
+ SearchEngineSelectorOld:
+ "resource://gre/modules/SearchEngineSelectorOld.sys.mjs",
+ SearchSettings: "resource://gre/modules/SearchSettings.sys.mjs",
+ SearchStaticData: "resource://gre/modules/SearchStaticData.sys.mjs",
+ SearchUtils: "resource://gre/modules/SearchUtils.sys.mjs",
+ UserSearchEngine: "resource://gre/modules/UserSearchEngine.sys.mjs",
+});
+
+ChromeUtils.defineLazyGetter(lazy, "logConsole", () => {
+ return console.createInstance({
+ prefix: "SearchService",
+ maxLogLevel: lazy.SearchUtils.loggingEnabled ? "Debug" : "Warn",
+ });
+});
+
+XPCOMUtils.defineLazyServiceGetter(
+ lazy,
+ "timerManager",
+ "@mozilla.org/updates/timer-manager;1",
+ "nsIUpdateTimerManager"
+);
+
+/**
+ * A reference to the handler for the default override allowlist.
+ *
+ * @type {SearchDefaultOverrideAllowlistHandler}
+ */
+ChromeUtils.defineLazyGetter(lazy, "defaultOverrideAllowlist", () => {
+ return new SearchDefaultOverrideAllowlistHandler();
+});
+
+// Exported to tests for not splitting ids when building webextension ids.
+export const NON_SPLIT_ENGINE_IDS = [
+ "allegro-pl",
+ "bok-NO",
+ "daum-kr",
+ "faclair-beag",
+ "gulesider-NO",
+ "mapy-cz",
+ "naver-kr",
+ "prisjakt-sv-SE",
+ "seznam-cz",
+ "tyda-sv-SE",
+ "wolnelektury-pl",
+ "yahoo-jp",
+ "yahoo-jp-auctions",
+];
+
+const TOPIC_LOCALES_CHANGE = "intl:app-locales-changed";
+const QUIT_APPLICATION_TOPIC = "quit-application";
+
+// The update timer for OpenSearch engines checks in once a day.
+const OPENSEARCH_UPDATE_TIMER_TOPIC = "search-engine-update-timer";
+const OPENSEARCH_UPDATE_TIMER_INTERVAL = 60 * 60 * 24;
+
+// This is the amount of time we'll be idle for before applying any configuration
+// changes.
+const RECONFIG_IDLE_TIME_SEC = 5 * 60;
+
+/**
+ * A reason that is used in the change of default search engine event telemetry.
+ * These are mutally exclusive.
+ */
+const REASON_CHANGE_MAP = new Map([
+ // The cause of the change is unknown.
+ [Ci.nsISearchService.CHANGE_REASON_UNKNOWN, "unknown"],
+ // The user changed the default search engine via the options in the
+ // preferences UI.
+ [Ci.nsISearchService.CHANGE_REASON_USER, "user"],
+ // The change resulted from the user toggling the "Use this search engine in
+ // Private Windows" option in the preferences UI.
+ [Ci.nsISearchService.CHANGE_REASON_USER_PRIVATE_SPLIT, "user_private_split"],
+ // The user changed the default via keys (cmd/ctrl-up/down) in the separate
+ // search bar.
+ [Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR, "user_searchbar"],
+ // The user changed the default via context menu on the one-off buttons in the
+ // separate search bar.
+ [
+ Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR_CONTEXT,
+ "user_searchbar_context",
+ ],
+ // An add-on requested the change of default on install, which was either
+ // accepted automatically or by the user.
+ [Ci.nsISearchService.CHANGE_REASON_ADDON_INSTALL, "addon-install"],
+ // An add-on was uninstalled, which caused the engine to be uninstalled.
+ [Ci.nsISearchService.CHANGE_REASON_ADDON_UNINSTALL, "addon-uninstall"],
+ // A configuration update caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_CONFIG, "config"],
+ // A locale update caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_LOCALE, "locale"],
+ // A region update caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_REGION, "region"],
+ // Turning on/off an experiment caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_EXPERIMENT, "experiment"],
+ // An enterprise policy caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_ENTERPRISE, "enterprise"],
+ // The UI Tour caused a change of default.
+ [Ci.nsISearchService.CHANGE_REASON_UITOUR, "uitour"],
+ // The engine updated.
+ [Ci.nsISearchService.CHANGE_REASON_ENGINE_UPDATE, "engine-update"],
+]);
+
+/**
+ * The ParseSubmissionResult contains getter methods that return attributes
+ * about the parsed submission url.
+ *
+ * @implements {nsIParseSubmissionResult}
+ */
+class ParseSubmissionResult {
+ constructor(engine, terms, termsParameterName) {
+ this.#engine = engine;
+ this.#terms = terms;
+ this.#termsParameterName = termsParameterName;
+ }
+
+ get engine() {
+ return this.#engine;
+ }
+
+ get terms() {
+ return this.#terms;
+ }
+
+ get termsParameterName() {
+ return this.#termsParameterName;
+ }
+
+ /**
+ * The search engine associated with the URL passed in to
+ * nsISearchEngine::parseSubmissionURL, or null if the URL does not represent
+ * a search submission.
+ *
+ * @type {nsISearchEngine|null}
+ */
+ #engine;
+
+ /**
+ * String containing the sought terms. This can be an empty string in case no
+ * terms were specified or the URL does not represent a search submission.*
+ *
+ * @type {string}
+ */
+ #terms;
+
+ /**
+ * The name of the query parameter used by `engine` for queries. E.g. "q".
+ *
+ * @type {string}
+ */
+ #termsParameterName;
+
+ QueryInterface = ChromeUtils.generateQI(["nsISearchParseSubmissionResult"]);
+}
+
+const gEmptyParseSubmissionResult = Object.freeze(
+ new ParseSubmissionResult(null, "", "")
+);
+
+/**
+ * The search service handles loading and maintaining of search engines. It will
+ * also work out the default lists for each locale/region.
+ *
+ * @implements {nsISearchService}
+ */
+export class SearchService {
+ constructor() {
+ // this._engines is prefixed with _ rather than # because it is called from
+ // a test.
+ this._engines = new Map();
+ this._settings = new lazy.SearchSettings(this);
+
+ this.#defineLazyPreferenceGetters();
+ }
+
+ classID = Components.ID("{7319788a-fe93-4db3-9f39-818cf08f4256}");
+
+ get defaultEngine() {
+ this.#ensureInitialized();
+ return this._getEngineDefault(false);
+ }
+
+ set defaultEngine(newEngine) {
+ this.#ensureInitialized();
+ this.#setEngineDefault(false, newEngine);
+ }
+
+ get defaultPrivateEngine() {
+ this.#ensureInitialized();
+ return this._getEngineDefault(this.#separatePrivateDefault);
+ }
+
+ set defaultPrivateEngine(newEngine) {
+ this.#ensureInitialized();
+ if (!this._separatePrivateDefaultPrefValue) {
+ Services.prefs.setBoolPref(
+ lazy.SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault",
+ true
+ );
+ }
+ this.#setEngineDefault(this.#separatePrivateDefault, newEngine);
+ }
+
+ async getDefault() {
+ await this.init();
+ return this.defaultEngine;
+ }
+
+ async setDefault(engine, changeSource) {
+ await this.init();
+ this.#setEngineDefault(false, engine, changeSource);
+ }
+
+ async getDefaultPrivate() {
+ await this.init();
+ return this.defaultPrivateEngine;
+ }
+
+ async setDefaultPrivate(engine, changeSource) {
+ await this.init();
+ if (!this._separatePrivateDefaultPrefValue) {
+ Services.prefs.setBoolPref(
+ lazy.SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault",
+ true
+ );
+ }
+ this.#setEngineDefault(this.#separatePrivateDefault, engine, changeSource);
+ }
+
+ /**
+ * @returns {SearchEngine}
+ * The engine that is the default for this locale/region, ignoring any
+ * user changes to the default engine.
+ */
+ get appDefaultEngine() {
+ return this.#appDefaultEngine();
+ }
+
+ /**
+ * @returns {SearchEngine}
+ * The engine that is the default for this locale/region in private browsing
+ * mode, ignoring any user changes to the default engine.
+ * Note: if there is no default for this locale/region, then the non-private
+ * browsing engine will be returned.
+ */
+ get appPrivateDefaultEngine() {
+ return this.#appDefaultEngine(this.#separatePrivateDefault);
+ }
+
+ /**
+ * Determine whether initialization has been completed.
+ *
+ * Clients of the service can use this attribute to quickly determine whether
+ * initialization is complete, and decide to trigger some immediate treatment,
+ * to launch asynchronous initialization or to bailout.
+ *
+ * Note that this attribute does not indicate that initialization has
+ * succeeded, use hasSuccessfullyInitialized() for that.
+ *
+ * @returns {boolean}
+ * |true | if the search service has finished its attempt to initialize and
+ * we have an outcome. It could have failed or succeeded during this
+ * process.
+ * |false| if initialization has not been triggered yet or initialization is
+ * still ongoing.
+ */
+ get isInitialized() {
+ return (
+ this.#initializationStatus == "success" ||
+ this.#initializationStatus == "failed"
+ );
+ }
+
+ /**
+ * Determine whether initialization has been successfully completed.
+ *
+ * @returns {boolean}
+ * |true | if the search service has succesfully initialized.
+ * |false| if initialization has not been started yet, initialization is
+ * still ongoing or initializaiton has failed.
+ */
+ get hasSuccessfullyInitialized() {
+ return this.#initializationStatus == "success";
+ }
+
+ /**
+ * A promise that is resolved when initialization has finished. This does not
+ * trigger initialization to begin.
+ *
+ * @returns {Promise}
+ * Resolved when initalization has successfully finished, and rejected if it
+ * has failed.
+ */
+ get promiseInitialized() {
+ return this.#initDeferredPromise.promise;
+ }
+
+ getDefaultEngineInfo() {
+ let [telemetryId, defaultSearchEngineData] = this.#getEngineInfo(
+ this.defaultEngine
+ );
+ const result = {
+ defaultSearchEngine: telemetryId,
+ defaultSearchEngineData,
+ };
+
+ if (this.#separatePrivateDefault) {
+ let [privateTelemetryId, defaultPrivateSearchEngineData] =
+ this.#getEngineInfo(this.defaultPrivateEngine);
+ result.defaultPrivateSearchEngine = privateTelemetryId;
+ result.defaultPrivateSearchEngineData = defaultPrivateSearchEngineData;
+ }
+
+ return result;
+ }
+
+ /**
+ * If possible, please call getEngineById() rather than getEngineByName()
+ * because engines are stored as { id: object } in this._engine Map.
+ *
+ * Returns the engine associated with the name.
+ *
+ * @param {string} engineName
+ * The name of the engine.
+ * @returns {SearchEngine}
+ * The associated engine if found, null otherwise.
+ */
+ getEngineByName(engineName) {
+ this.#ensureInitialized();
+ return this.#getEngineByName(engineName);
+ }
+
+ /**
+ * Returns the engine associated with the name without initialization checks.
+ *
+ * @param {string} engineName
+ * The name of the engine.
+ * @returns {SearchEngine}
+ * The associated engine if found, null otherwise.
+ */
+ #getEngineByName(engineName) {
+ for (let engine of this._engines.values()) {
+ if (engine.name == engineName) {
+ return engine;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the engine associated with the id.
+ *
+ * @param {string} engineId
+ * The id of the engine.
+ * @returns {SearchEngine}
+ * The associated engine if found, null otherwise.
+ */
+ getEngineById(engineId) {
+ this.#ensureInitialized();
+ return this._engines.get(engineId) || null;
+ }
+
+ async getEngineByAlias(alias) {
+ await this.init();
+ for (var engine of this._engines.values()) {
+ if (engine && engine.aliases.includes(alias)) {
+ return engine;
+ }
+ }
+ return null;
+ }
+
+ async getEngines() {
+ await this.init();
+ lazy.logConsole.debug("getEngines: getting all engines");
+ return this.#sortedEngines;
+ }
+
+ async getVisibleEngines() {
+ await this.init(true);
+ lazy.logConsole.debug("getVisibleEngines: getting all visible engines");
+ return this.#sortedVisibleEngines;
+ }
+
+ async getAppProvidedEngines() {
+ await this.init();
+
+ return this._sortEnginesByDefaults(
+ this.#sortedEngines.filter(e => e.isAppProvided)
+ );
+ }
+
+ async getEnginesByExtensionID(extensionID) {
+ await this.init();
+ return this.#getEnginesByExtensionID(extensionID);
+ }
+
+ /**
+ * This function calls #init to start initialization when it has not been
+ * started yet. Otherwise, it returns the pending promise.
+ *
+ * @returns {Promise}
+ * Returns the pending Promise when #init has started but not yet finished.
+ * | Resolved | when initialization has successfully finished.
+ * | Rejected | when initialization has failed.
+ *
+ */
+ async init() {
+ if (["started", "success", "failed"].includes(this.#initializationStatus)) {
+ return this.promiseInitialized;
+ }
+ this.#initializationStatus = "started";
+ return this.#init();
+ }
+
+ /**
+ * Runs background checks for the search service. This is called from
+ * BrowserGlue and may be run once per session if the user is idle for
+ * long enough.
+ */
+ async runBackgroundChecks() {
+ await this.init();
+ await this.#migrateLegacyEngines();
+ await this.#checkWebExtensionEngines();
+ await this.#addOpenSearchTelemetry();
+ }
+
+ /**
+ * Test only - reset SearchService data. Ideally this should be replaced
+ */
+ reset() {
+ this.#initializationStatus = "not initialized";
+ this.#initDeferredPromise = Promise.withResolvers();
+ this.#startupExtensions = new Set();
+ this._engines.clear();
+ this._cachedSortedEngines = null;
+ this.#currentEngine = null;
+ this.#currentPrivateEngine = null;
+ this._searchDefault = null;
+ this.#searchPrivateDefault = null;
+ this.#maybeReloadDebounce = false;
+ this._settings._batchTask?.disarm();
+ if (this.#engineSelector) {
+ this.#engineSelector.reset();
+ this.#engineSelector = null;
+ }
+ }
+
+ // Test-only function to set SearchService initialization status
+ forceInitializationStatusForTests(status) {
+ this.#initializationStatus = status;
+ }
+
+ /**
+ * Test only variable to indicate an error should occur during
+ * search service initialization.
+ *
+ * @type {string}
+ */
+ errorToThrowInTest = null;
+
+ // Test-only function to reset just the engine selector so that it can
+ // load a different configuration.
+ resetEngineSelector() {
+ if (lazy.SearchUtils.newSearchConfigEnabled) {
+ this.#engineSelector = new lazy.SearchEngineSelector(
+ this.#handleConfigurationUpdated.bind(this)
+ );
+ } else {
+ this.#engineSelector = new lazy.SearchEngineSelectorOld(
+ this.#handleConfigurationUpdated.bind(this)
+ );
+ }
+ }
+
+ resetToAppDefaultEngine() {
+ let appDefaultEngine = this.appDefaultEngine;
+ appDefaultEngine.hidden = false;
+ this.defaultEngine = appDefaultEngine;
+ }
+
+ async maybeSetAndOverrideDefault(extension) {
+ let searchProvider =
+ extension.manifest.chrome_settings_overrides.search_provider;
+ let engine = this.getEngineByName(searchProvider.name);
+ if (!engine || !engine.isAppProvided || engine.hidden) {
+ // If the engine is not application provided, then we shouldn't simply
+ // set default to it.
+ // If the engine is application provided, but hidden, then we don't
+ // switch to it, nor do we try to install it.
+ return {
+ canChangeToAppProvided: false,
+ canInstallEngine: !engine?.hidden,
+ };
+ }
+
+ if (
+ extension.startupReason === "ADDON_INSTALL" ||
+ extension.startupReason === "ADDON_ENABLE"
+ ) {
+ // Don't allow an extension to set the default if it is already the default.
+ if (this.defaultEngine.name == searchProvider.name) {
+ return {
+ canChangeToAppProvided: false,
+ canInstallEngine: false,
+ };
+ }
+ if (
+ !(await lazy.defaultOverrideAllowlist.canOverride(
+ extension,
+ engine._extensionID
+ ))
+ ) {
+ lazy.logConsole.debug(
+ "Allowing default engine to be set to app-provided.",
+ extension.id
+ );
+ // We don't allow overriding the engine in this case, but we can allow
+ // the extension to change the default engine.
+ return {
+ canChangeToAppProvided: true,
+ canInstallEngine: false,
+ };
+ }
+ // We're ok to override.
+ engine.overrideWithEngine({ extension });
+ lazy.logConsole.debug(
+ "Allowing default engine to be set to app-provided and overridden.",
+ extension.id
+ );
+ return {
+ canChangeToAppProvided: true,
+ canInstallEngine: false,
+ };
+ }
+
+ if (
+ engine.getAttr("overriddenBy") == extension.id &&
+ (await lazy.defaultOverrideAllowlist.canOverride(
+ extension,
+ engine._extensionID
+ ))
+ ) {
+ engine.overrideWithEngine({ extension });
+ lazy.logConsole.debug(
+ "Re-enabling overriding of core extension by",
+ extension.id
+ );
+ return {
+ canChangeToAppProvided: true,
+ canInstallEngine: false,
+ };
+ }
+
+ return {
+ canChangeToAppProvided: false,
+ canInstallEngine: false,
+ };
+ }
+
+ /**
+ * Adds a search engine that is specified from enterprise policies.
+ *
+ * @param {object} details
+ * An object that matches the `SearchEngines` policy schema.
+ * @param {object} [settings]
+ * The saved settings for the user.
+ * @see browser/components/enterprisepolicies/schemas/policies-schema.json
+ */
+ async #addPolicyEngine(details, settings) {
+ let newEngine = new lazy.PolicySearchEngine({ details, settings });
+ lazy.logConsole.debug("Adding Policy Engine:", newEngine.name);
+ this.#addEngineToStore(newEngine);
+ }
+
+ /**
+ * Adds a search engine that is specified by the user.
+ *
+ * @param {string} name
+ * The name of the search engine
+ * @param {string} url
+ * The url that the search engine uses for searches
+ * @param {string} alias
+ * An alias for the search engine
+ */
+ async addUserEngine(name, url, alias) {
+ await this.init();
+
+ let newEngine = new lazy.UserSearchEngine({
+ details: { name, url, alias },
+ });
+ lazy.logConsole.debug(`Adding ${newEngine.name}`);
+ this.#addEngineToStore(newEngine);
+ }
+
+ /**
+ * Called from the AddonManager when it either installs a new
+ * extension containing a search engine definition or an upgrade
+ * to an existing one.
+ *
+ * @param {object} extension
+ * An Extension object containing data about the extension.
+ */
+ async addEnginesFromExtension(extension) {
+ lazy.logConsole.debug("addEnginesFromExtension: " + extension.id);
+ // Treat add-on upgrade and downgrades the same - either way, the search
+ // engine gets updated, not added. Generally, we don't expect a downgrade,
+ // but just in case...
+ if (
+ extension.startupReason == "ADDON_UPGRADE" ||
+ extension.startupReason == "ADDON_DOWNGRADE"
+ ) {
+ // Bug 1679861 An a upgrade or downgrade could be adding a search engine
+ // that was not in a prior version, or the addon may have been blocklisted.
+ // In either case, there will not be an existing engine.
+ let existing = await this.#upgradeExtensionEngine(extension);
+ if (existing?.length) {
+ return existing;
+ }
+ }
+
+ if (extension.isAppProvided) {
+ // If we are in the middle of initialization or reloading engines,
+ // don't add the engine here. This has been called as the result
+ // of _makeEngineFromConfig installing the extension, and that is already
+ // handling the addition of the engine.
+ if (this.isInitialized && !this._reloadingEngines) {
+ let { engines } = await this._fetchEngineSelectorEngines();
+ let inConfig = engines.filter(el => el.webExtension.id == extension.id);
+ if (inConfig.length) {
+ return this.#installExtensionEngine(
+ extension,
+ inConfig.map(el => el.webExtension.locale)
+ );
+ }
+ }
+ lazy.logConsole.debug(
+ "addEnginesFromExtension: Ignoring builtIn engine."
+ );
+ return [];
+ }
+
+ // If we havent started SearchService yet, store this extension
+ // to install in SearchService.init().
+ if (!this.isInitialized) {
+ this.#startupExtensions.add(extension);
+ return [];
+ }
+
+ return this.#installExtensionEngine(extension, [
+ lazy.SearchUtils.DEFAULT_TAG,
+ ]);
+ }
+
+ async addOpenSearchEngine(engineURL, iconURL) {
+ lazy.logConsole.debug("addOpenSearchEngine: Adding", engineURL);
+ await this.init();
+ let engine;
+ try {
+ let engineData = await lazy.loadAndParseOpenSearchEngine(
+ Services.io.newURI(engineURL)
+ );
+ engine = new lazy.OpenSearchEngine({ engineData });
+ engine._setIcon(iconURL, false);
+ } catch (ex) {
+ throw Components.Exception(
+ "addEngine: Error adding engine:\n" + ex,
+ ex.result || Cr.NS_ERROR_FAILURE
+ );
+ }
+ this.#addEngineToStore(engine);
+ this.#maybeStartOpenSearchUpdateTimer();
+ return engine;
+ }
+
+ async removeWebExtensionEngine(id) {
+ if (!this.isInitialized) {
+ lazy.logConsole.debug(
+ "Delaying removing extension engine on startup:",
+ id
+ );
+ this.#startupRemovedExtensions.add(id);
+ return;
+ }
+
+ lazy.logConsole.debug("removeWebExtensionEngine:", id);
+ for (let engine of this.#getEnginesByExtensionID(id)) {
+ await this.removeEngine(engine);
+ }
+ }
+
+ async removeEngine(engine) {
+ await this.init();
+ if (!engine) {
+ throw Components.Exception(
+ "no engine passed to removeEngine!",
+ Cr.NS_ERROR_INVALID_ARG
+ );
+ }
+
+ var engineToRemove = null;
+ for (var e of this._engines.values()) {
+ if (engine.wrappedJSObject == e) {
+ engineToRemove = e;
+ }
+ }
+
+ if (!engineToRemove) {
+ throw Components.Exception(
+ "removeEngine: Can't find engine to remove!",
+ Cr.NS_ERROR_FILE_NOT_FOUND
+ );
+ }
+
+ engineToRemove.pendingRemoval = true;
+
+ if (engineToRemove == this.defaultEngine) {
+ this.#findAndSetNewDefaultEngine({
+ privateMode: false,
+ });
+ }
+
+ // Bug 1575649 - We can't just check the default private engine here when
+ // we're not using separate, as that re-checks the normal default, and
+ // triggers update of the default search engine, which messes up various
+ // tests. Really, removeEngine should always commit to updating any
+ // changed defaults.
+ if (
+ this.#separatePrivateDefault &&
+ engineToRemove == this.defaultPrivateEngine
+ ) {
+ this.#findAndSetNewDefaultEngine({
+ privateMode: true,
+ });
+ }
+
+ if (engineToRemove.inMemory) {
+ // Just hide it (the "hidden" setter will notify) and remove its alias to
+ // avoid future conflicts with other engines.
+ engineToRemove.hidden = true;
+ engineToRemove.alias = null;
+ engineToRemove.pendingRemoval = false;
+ } else {
+ // Remove the engine file from disk if we had a legacy file in the profile.
+ if (engineToRemove._filePath) {
+ let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
+ file.persistentDescriptor = engineToRemove._filePath;
+ if (file.exists()) {
+ file.remove(false);
+ }
+ engineToRemove._filePath = null;
+ }
+ this.#internalRemoveEngine(engineToRemove);
+
+ // Since we removed an engine, we may need to update the preferences.
+ if (!this.#dontSetUseSavedOrder) {
+ this.#saveSortedEngineList();
+ }
+ }
+ lazy.SearchUtils.notifyAction(
+ engineToRemove,
+ lazy.SearchUtils.MODIFIED_TYPE.REMOVED
+ );
+ }
+
+ async moveEngine(engine, newIndex) {
+ await this.init();
+ if (newIndex > this.#sortedEngines.length || newIndex < 0) {
+ throw Components.Exception(
+ "moveEngine: Index out of bounds!",
+ Cr.NS_ERROR_INVALID_ARG
+ );
+ }
+ if (
+ !(engine instanceof Ci.nsISearchEngine) &&
+ !(engine instanceof lazy.SearchEngine)
+ ) {
+ throw Components.Exception(
+ "moveEngine: Invalid engine passed to moveEngine!",
+ Cr.NS_ERROR_INVALID_ARG
+ );
+ }
+ if (engine.hidden) {
+ throw Components.Exception(
+ "moveEngine: Can't move a hidden engine!",
+ Cr.NS_ERROR_FAILURE
+ );
+ }
+
+ engine = engine.wrappedJSObject;
+
+ var currentIndex = this.#sortedEngines.indexOf(engine);
+ if (currentIndex == -1) {
+ throw Components.Exception(
+ "moveEngine: Can't find engine to move!",
+ Cr.NS_ERROR_UNEXPECTED
+ );
+ }
+
+ // Our callers only take into account non-hidden engines when calculating
+ // newIndex, but we need to move it in the array of all engines, so we
+ // need to adjust newIndex accordingly. To do this, we count the number
+ // of hidden engines in the list before the engine that we're taking the
+ // place of. We do this by first finding newIndexEngine (the engine that
+ // we were supposed to replace) and then iterating through the complete
+ // engine list until we reach it, increasing newIndex for each hidden
+ // engine we find on our way there.
+ //
+ // This could be further simplified by having our caller pass in
+ // newIndexEngine directly instead of newIndex.
+ var newIndexEngine = this.#sortedVisibleEngines[newIndex];
+ if (!newIndexEngine) {
+ throw Components.Exception(
+ "moveEngine: Can't find engine to replace!",
+ Cr.NS_ERROR_UNEXPECTED
+ );
+ }
+
+ for (var i = 0; i < this.#sortedEngines.length; ++i) {
+ if (newIndexEngine == this.#sortedEngines[i]) {
+ break;
+ }
+ if (this.#sortedEngines[i].hidden) {
+ newIndex++;
+ }
+ }
+
+ if (currentIndex == newIndex) {
+ return;
+ } // nothing to do!
+
+ // Move the engine
+ var movedEngine = this._cachedSortedEngines.splice(currentIndex, 1)[0];
+ this._cachedSortedEngines.splice(newIndex, 0, movedEngine);
+
+ lazy.SearchUtils.notifyAction(
+ engine,
+ lazy.SearchUtils.MODIFIED_TYPE.CHANGED
+ );
+
+ // Since we moved an engine, we need to update the preferences.
+ this.#saveSortedEngineList();
+ }
+
+ restoreDefaultEngines() {
+ this.#ensureInitialized();
+ for (let e of this._engines.values()) {
+ // Unhide all default engines
+ if (e.hidden && e.isAppProvided) {
+ e.hidden = false;
+ }
+ }
+ }
+
+ parseSubmissionURL(url) {
+ if (!this.hasSuccessfullyInitialized) {
+ // If search is not initialized or failed initializing, do nothing.
+ // This allows us to use this function early in telemetry.
+ // The only other consumer of this (places) uses it much later.
+ return gEmptyParseSubmissionResult;
+ }
+
+ if (!this.#parseSubmissionMap) {
+ this.#buildParseSubmissionMap();
+ }
+
+ // Extract the elements of the provided URL first.
+ let soughtKey, soughtQuery;
+ try {
+ let soughtUrl = Services.io.newURI(url);
+
+ // Exclude any URL that is not HTTP or HTTPS from the beginning.
+ if (soughtUrl.schemeIs("http") && soughtUrl.schemeIs("https")) {
+ return gEmptyParseSubmissionResult;
+ }
+
+ // Reading these URL properties may fail and raise an exception.
+ soughtKey = soughtUrl.host + soughtUrl.filePath.toLowerCase();
+ soughtQuery = soughtUrl.query;
+ } catch (ex) {
+ // Errors while parsing the URL or accessing the properties are not fatal.
+ return gEmptyParseSubmissionResult;
+ }
+
+ // Look up the domain and path in the map to identify the search engine.
+ let mapEntry = this.#parseSubmissionMap.get(soughtKey);
+ if (!mapEntry) {
+ return gEmptyParseSubmissionResult;
+ }
+
+ // Extract the search terms from the parameter, for example "caff%C3%A8"
+ // from the URL "https://www.google.com/search?q=caff%C3%A8&client=firefox".
+ // We cannot use `URLSearchParams` here as the terms might not be
+ // encoded in UTF-8.
+ let encodedTerms = null;
+ for (let param of soughtQuery.split("&")) {
+ let equalPos = param.indexOf("=");
+ if (
+ equalPos != -1 &&
+ param.substr(0, equalPos) == mapEntry.termsParameterName
+ ) {
+ // This is the parameter we are looking for.
+ encodedTerms = param.substr(equalPos + 1);
+ break;
+ }
+ }
+ if (encodedTerms === null) {
+ return gEmptyParseSubmissionResult;
+ }
+
+ // Decode the terms using the charset defined in the search engine.
+ let terms;
+ try {
+ terms = Services.textToSubURI.UnEscapeAndConvert(
+ mapEntry.engine.queryCharset,
+ encodedTerms.replace(/\+/g, " ")
+ );
+ } catch (ex) {
+ // Decoding errors will cause this match to be ignored.
+ return gEmptyParseSubmissionResult;
+ }
+
+ return new ParseSubmissionResult(
+ mapEntry.engine,
+ terms,
+ mapEntry.termsParameterName
+ );
+ }
+
+ /**
+ * This is a nsITimerCallback for the timerManager notification that is
+ * registered for handling updates to search engines. Only OpenSearch engines
+ * have these updates and hence, only those are handled here.
+ */
+ async notify() {
+ lazy.logConsole.debug("notify: checking for updates");
+
+ // Walk the engine list, looking for engines whose update time has expired.
+ for (let engine of this._engines.values()) {
+ if (!(engine instanceof lazy.OpenSearchEngine)) {
+ continue;
+ }
+ await engine.maybeUpdate();
+ }
+ }
+
+ #currentEngine;
+ #currentPrivateEngine;
+ #queuedIdle;
+
+ /**
+ * A deferred promise that is resolved when initialization has finished.
+ *
+ * @type {Promise}
+ * Resolved when initalization has successfully finished, and rejected if it
+ * has failed.
+ */
+ #initDeferredPromise = Promise.withResolvers();
+
+ /**
+ * Indicates if initialization has started, failed, succeeded or has not
+ * started yet.
+ *
+ * These are the statuses:
+ * "not initialized" - The SearchService has not started initialization.
+ * "started" - The SearchService has started initializaiton.
+ * "success" - The SearchService successfully completed initialization.
+ * "failed" - The SearchService failed during initialization.
+ *
+ * @type {string}
+ */
+ #initializationStatus = "not initialized";
+
+ /**
+ * Indicates if we're already waiting for maybeReloadEngines to be called.
+ *
+ * @type {boolean}
+ */
+ #maybeReloadDebounce = false;
+
+ /**
+ * Indicates if we're currently in maybeReloadEngines.
+ *
+ * This is prefixed with _ rather than # because it is
+ * called in a test.
+ *
+ * @type {boolean}
+ */
+ _reloadingEngines = false;
+
+ /**
+ * The engine selector singleton that is managing the engine configuration.
+ *
+ * @type {SearchEngineSelector|null}
+ */
+ #engineSelector = null;
+
+ /**
+ * Various search engines may be ignored if their submission urls contain a
+ * string that is in the list. The list is controlled via remote settings.
+ *
+ * @type {Array}
+ */
+ #submissionURLIgnoreList = [];
+
+ /**
+ * Various search engines may be ignored if their load path is contained
+ * in this list. The list is controlled via remote settings.
+ *
+ * @type {Array}
+ */
+ #loadPathIgnoreList = [];
+
+ /**
+ * A map of engine display names to `SearchEngine`.
+ *
+ * @type {Map<string, object>|null}
+ */
+ _engines = null;
+
+ /**
+ * An array of engine short names sorted into display order.
+ *
+ * @type {Array}
+ */
+ _cachedSortedEngines = null;
+
+ /**
+ * A flag to prevent setting of useSavedOrder when there's non-user
+ * activity happening.
+ *
+ * @type {boolean}
+ */
+ #dontSetUseSavedOrder = false;
+
+ /**
+ * An object containing the {id, locale} of the WebExtension for the default
+ * engine, as suggested by the configuration.
+ * For the legacy configuration, this is the user visible name.
+ *
+ * @type {object}
+ *
+ * This is prefixed with _ rather than # because it is
+ * called in a test.
+ */
+ _searchDefault = null;
+
+ /**
+ * An object containing the {id, locale} of the WebExtension for the default
+ * engine for private browsing mode, as suggested by the configuration.
+ * For the legacy configuration, this is the user visible name.
+ *
+ * @type {object}
+ */
+ #searchPrivateDefault = null;
+
+ /**
+ * A Set of installed search extensions reported by AddonManager
+ * startup before SearchSevice has started. Will be installed
+ * during init().
+ *
+ * @type {Set<object>}
+ */
+ #startupExtensions = new Set();
+
+ /**
+ * A Set of removed search extensions reported by AddonManager
+ * startup before SearchSevice has started. Will be removed
+ * during init().
+ *
+ * @type {Set<object>}
+ */
+ #startupRemovedExtensions = new Set();
+
+ /**
+ * This map is built lazily after the available search engines change. It
+ * allows quick parsing of an URL representing a search submission into the
+ * search engine name and original terms.
+ *
+ * The keys are strings containing the domain name and lowercase path of the
+ * engine submission, for example "www.google.com/search".
+ *
+ * The values are objects with these properties:
+ * {
+ * engine: The associated nsISearchEngine.
+ * termsParameterName: Name of the URL parameter containing the search
+ * terms, for example "q".
+ * }
+ */
+ #parseSubmissionMap = null;
+
+ /**
+ * Keep track of observers have been added.
+ *
+ * @type {boolean}
+ */
+ #observersAdded = false;
+
+ /**
+ * Keeps track to see if the OpenSearch update timer has been started or not.
+ *
+ * @type {boolean}
+ */
+ #openSearchUpdateTimerStarted = false;
+
+ get #sortedEngines() {
+ if (!this._cachedSortedEngines) {
+ return this.#buildSortedEngineList();
+ }
+ return this._cachedSortedEngines;
+ }
+ /**
+ * This reflects the combined values of the prefs for enabling the separate
+ * private default UI, and for the user choosing a separate private engine.
+ * If either one is disabled, then we don't enable the separate private default.
+ *
+ * @returns {boolean}
+ */
+ get #separatePrivateDefault() {
+ return (
+ this._separatePrivateDefaultPrefValue &&
+ this._separatePrivateDefaultEnabledPrefValue
+ );
+ }
+
+ #getEnginesByExtensionID(extensionID) {
+ lazy.logConsole.debug("getEngines: getting all engines for", extensionID);
+ var engines = this.#sortedEngines.filter(function (engine) {
+ return engine._extensionID == extensionID;
+ });
+ return engines;
+ }
+
+ /**
+ * Returns the engine associated with the WebExtension details.
+ *
+ * @param {object} details
+ * Details of the WebExtension.
+ * @param {string} details.id
+ * The WebExtension ID
+ * @param {string} details.locale
+ * The WebExtension locale
+ * @returns {nsISearchEngine|null}
+ * The found engine, or null if no engine matched.
+ */
+ #getEngineByWebExtensionDetails(details) {
+ for (const engine of this._engines.values()) {
+ if (
+ engine._extensionID == details.id &&
+ engine._locale == details.locale
+ ) {
+ return engine;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Helper function to get the current default engine.
+ *
+ * This is prefixed with _ rather than # because it is
+ * called in test_remove_engine_notification_box.js
+ *
+ * @param {boolean} privateMode
+ * If true, returns the default engine for private browsing mode, otherwise
+ * the default engine for the normal mode. Note, this function does not
+ * check the "separatePrivateDefault" preference - that is up to the caller.
+ * @returns {nsISearchEngine|null}
+ * The appropriate search engine, or null if one could not be determined.
+ */
+ _getEngineDefault(privateMode) {
+ let currentEngine = privateMode
+ ? this.#currentPrivateEngine
+ : this.#currentEngine;
+
+ if (currentEngine && !currentEngine.hidden) {
+ return currentEngine;
+ }
+
+ // No default loaded, so find it from settings.
+ const attributeName = privateMode
+ ? "privateDefaultEngineId"
+ : "defaultEngineId";
+
+ let engineId = this._settings.getMetaDataAttribute(attributeName);
+ let engine = this._engines.get(engineId) || null;
+ if (
+ engine &&
+ this._settings.getVerifiedMetaDataAttribute(
+ attributeName,
+ engine.isAppProvided
+ )
+ ) {
+ if (privateMode) {
+ this.#currentPrivateEngine = engine;
+ } else {
+ this.#currentEngine = engine;
+ }
+ }
+ if (!engineId) {
+ if (privateMode) {
+ this.#currentPrivateEngine = this.appPrivateDefaultEngine;
+ } else {
+ this.#currentEngine = this.appDefaultEngine;
+ }
+ }
+
+ currentEngine = privateMode
+ ? this.#currentPrivateEngine
+ : this.#currentEngine;
+ if (currentEngine && !currentEngine.hidden) {
+ return currentEngine;
+ }
+ // No default in settings or it is hidden, so find the new default.
+ return this.#findAndSetNewDefaultEngine({ privateMode });
+ }
+
+ /**
+ * If initialization has not been completed yet, perform synchronous
+ * initialization.
+ * Throws in case of initialization error.
+ */
+ #ensureInitialized() {
+ if (this.#initializationStatus === "success") {
+ return;
+ }
+
+ if (this.#initializationStatus === "failed") {
+ throw new Error("SearchService failed while it was initializing.");
+ }
+
+ let err = new Error(
+ "Something tried to use the search service before it finished " +
+ "initializing. Please examine the stack trace to figure out what and " +
+ "where to fix it:\n"
+ );
+ err.message += err.stack;
+ throw err;
+ }
+
+ /**
+ * Define lazy preference getters for separate private default engine in
+ * private browsing mode.
+ */
+ #defineLazyPreferenceGetters() {
+ XPCOMUtils.defineLazyPreferenceGetter(
+ this,
+ "_separatePrivateDefaultPrefValue",
+ lazy.SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault",
+ false,
+ this.#onSeparateDefaultPrefChanged.bind(this)
+ );
+
+ XPCOMUtils.defineLazyPreferenceGetter(
+ this,
+ "_separatePrivateDefaultEnabledPrefValue",
+ lazy.SearchUtils.BROWSER_SEARCH_PREF +
+ "separatePrivateDefault.ui.enabled",
+ false,
+ this.#onSeparateDefaultPrefChanged.bind(this)
+ );
+
+ XPCOMUtils.defineLazyPreferenceGetter(
+ this,
+ "separatePrivateDefaultUrlbarResultEnabled",
+ lazy.SearchUtils.BROWSER_SEARCH_PREF +
+ "separatePrivateDefault.urlbarResult.enabled",
+ false
+ );
+ }
+
+ /**
+ * This function adds observers, retrieves the search engine ignore list, and
+ * initializes the Search Engine Selector prior to doing the core tasks of
+ * search service initialization.
+ *
+ */
+ #doPreInitWork() {
+ // We need to catch the region being updated during initialization so we
+ // start listening straight away.
+ Services.obs.addObserver(this, lazy.Region.REGION_TOPIC);
+
+ this.#getIgnoreListAndSubscribe().catch(ex =>
+ console.error(ex, "Search Service could not get the ignore list.")
+ );
+
+ if (lazy.SearchUtils.newSearchConfigEnabled) {
+ this.#engineSelector = new lazy.SearchEngineSelector(
+ this.#handleConfigurationUpdated.bind(this)
+ );
+ } else {
+ this.#engineSelector = new lazy.SearchEngineSelectorOld(
+ this.#handleConfigurationUpdated.bind(this)
+ );
+ }
+ }
+
+ /**
+ * This function fetches information to load search engines and ensures the
+ * search service is in the correct state for external callers to interact
+ * with it.
+ *
+ * This function sets #initDeferredPromise to resolve or reject.
+ * | Resolved | when initalization has successfully finished.
+ * | Rejected | when initialization has failed.
+ */
+ async #init() {
+ lazy.logConsole.debug("init");
+
+ const timerId = Glean.searchService.startupTime.start();
+
+ this.#doPreInitWork();
+
+ let initSection;
+ try {
+ initSection = "Settings";
+ this.#maybeThrowErrorInTest(initSection);
+ const settings = await this._settings.get();
+
+ initSection = "FetchEngines";
+ this.#maybeThrowErrorInTest(initSection);
+ const { engines, privateDefault } =
+ await this._fetchEngineSelectorEngines();
+
+ initSection = "LoadEngines";
+ this.#maybeThrowErrorInTest(initSection);
+ await this.#loadEngines(settings, engines, privateDefault);
+ } catch (ex) {
+ Glean.searchService.initializationStatus[`failed${initSection}`].add();
+ Glean.searchService.startupTime.cancel(timerId);
+
+ lazy.logConsole.error("#init: failure initializing search:", ex);
+ this.#initializationStatus = "failed";
+ this.#initDeferredPromise.reject(ex);
+
+ throw ex;
+ }
+
+ // If we've got this far, but the application is now shutting down,
+ // then we need to abandon any further work, especially not writing
+ // the settings. We do this, because the add-on manager has also
+ // started shutting down and as a result, we might have an incomplete
+ // picture of the installed search engines. Writing the settings at
+ // this stage would potentially mean the user would loose their engine
+ // data.
+ // We will however, rebuild the settings on next start up if we detect
+ // it is necessary.
+ if (Services.startup.shuttingDown) {
+ Glean.searchService.startupTime.cancel(timerId);
+
+ let ex = Components.Exception(
+ "#init: abandoning init due to shutting down",
+ Cr.NS_ERROR_ABORT
+ );
+
+ this.#initializationStatus = "failed";
+ this.#initDeferredPromise.reject(ex);
+ throw ex;
+ }
+
+ this.#initializationStatus = "success";
+ Glean.searchService.initializationStatus.success.add();
+ this.#initDeferredPromise.resolve();
+ this.#addObservers();
+
+ Glean.searchService.startupTime.stopAndAccumulate(timerId);
+
+ this.#recordTelemetryData();
+
+ Services.obs.notifyObservers(
+ null,
+ lazy.SearchUtils.TOPIC_SEARCH_SERVICE,
+ "init-complete"
+ );
+
+ lazy.logConsole.debug("Completed #init");
+ this.#doPostInitWork();
+ }
+
+ /**
+ * This function records telemetry, checks experiment updates, sets up a timer
+ * for opensearch, removes any necessary Add-on engines immediately after the
+ * search service has successfully initialized.
+ *
+ */
+ #doPostInitWork() {
+ // It is possible that Nimbus could have called onUpdate before
+ // we started listening, so do a check on startup.
+ Services.tm.dispatchToMainThread(async () => {
+ await lazy.NimbusFeatures.searchConfiguration.ready();
+ this.#checkNimbusPrefs(true);
+ });
+
+ this.#maybeStartOpenSearchUpdateTimer();
+
+ if (this.#startupRemovedExtensions.size) {
+ Services.tm.dispatchToMainThread(async () => {
+ // Now that init() has successfully finished, we remove any engines
+ // that have had their add-ons removed by the add-on manager.
+ // We do this after init() has complete, as that allows us to use
+ // removeEngine to look after any default engine changes as well.
+ // This could cause a slight flicker on startup, but it should be
+ // a rare action.
+ lazy.logConsole.debug("Removing delayed extension engines");
+ for (let id of this.#startupRemovedExtensions) {
+ for (let engine of this.#getEnginesByExtensionID(id)) {
+ // Only do this for non-application provided engines. We shouldn't
+ // ever get application provided engines removed here, but just in case.
+ if (!engine.isAppProvided) {
+ await this.removeEngine(engine);
+ }
+ }
+ }
+ this.#startupRemovedExtensions.clear();
+ });
+ }
+ }
+
+ /**
+ * Obtains the ignore list from remote settings. This should only be
+ * called from init(). Any subsequent updates to the remote settings are
+ * handled via a sync listener.
+ *
+ */
+ async #getIgnoreListAndSubscribe() {
+ let listener = this.#handleIgnoreListUpdated.bind(this);
+ const current = await lazy.IgnoreLists.getAndSubscribe(listener);
+
+ // Only save the listener after the subscribe, otherwise for tests it might
+ // not be fully set up by the time we remove it again.
+ this.ignoreListListener = listener;
+
+ await this.#handleIgnoreListUpdated({ data: { current } });
+ Services.obs.notifyObservers(
+ null,
+ lazy.SearchUtils.TOPIC_SEARCH_SERVICE,
+ "settings-update-complete"
+ );
+ }
+
+ /**
+ * This handles updating of the ignore list settings, and removing any ignored
+ * engines.
+ *
+ * @param {object} eventData
+ * The event in the format received from RemoteSettings.
+ */
+ async #handleIgnoreListUpdated(eventData) {
+ lazy.logConsole.debug("#handleIgnoreListUpdated");
+ const {
+ data: { current },
+ } = eventData;
+
+ for (const entry of current) {
+ if (entry.id == "load-paths") {
+ this.#loadPathIgnoreList = [...entry.matches];
+ } else if (entry.id == "submission-urls") {
+ this.#submissionURLIgnoreList = [...entry.matches];
+ }
+ }
+
+ try {
+ await this.promiseInitialized;
+ } catch (ex) {
+ // If there's a problem with initialization return early to allow
+ // search service to continue in a limited mode without engines.
+ return;
+ }
+
+ // We try to remove engines manually, as this should be more efficient and
+ // we don't really want to cause a re-init as this upsets unit tests.
+ let engineRemoved = false;
+ for (let engine of this._engines.values()) {
+ if (this.#engineMatchesIgnoreLists(engine)) {
+ await this.removeEngine(engine);
+ engineRemoved = true;
+ }
+ }
+ // If we've removed an engine, and we don't have any left, we need to
+ // reload the engines - it is possible the settings just had one engine in it,
+ // and that is now empty, so we need to load from our main list.
+ if (engineRemoved && !this._engines.size) {
+ this._maybeReloadEngines().catch(console.error);
+ }
+ }
+
+ /**
+ * Determines if a given engine matches the ignorelists or not.
+ *
+ * @param {Engine} engine
+ * The engine to check against the ignorelists.
+ * @returns {boolean}
+ * Returns true if the engine matches a ignorelists entry.
+ */
+ #engineMatchesIgnoreLists(engine) {
+ if (this.#loadPathIgnoreList.includes(engine._loadPath)) {
+ return true;
+ }
+ let url = engine.searchURLWithNoTerms.spec.toLowerCase();
+ if (
+ this.#submissionURLIgnoreList.some(code =>
+ url.includes(code.toLowerCase())
+ )
+ ) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Handles the search configuration being - adds a wait on the user
+ * being idle, before the search engine update gets handled.
+ */
+ #handleConfigurationUpdated() {
+ if (this.#queuedIdle) {
+ return;
+ }
+
+ this.#queuedIdle = true;
+
+ this.idleService.addIdleObserver(this, RECONFIG_IDLE_TIME_SEC);
+ }
+
+ /**
+ * Returns the engine that is the default for this locale/region, ignoring any
+ * user changes to the default engine.
+ *
+ * @param {boolean} privateMode
+ * Set to true to return the default engine in private mode,
+ * false for normal mode.
+ * @returns {SearchEngine}
+ * The engine that is default.
+ */
+ #appDefaultEngine(privateMode = false) {
+ let defaultEngine = this.#getEngineByWebExtensionDetails(
+ privateMode && this.#searchPrivateDefault
+ ? this.#searchPrivateDefault
+ : this._searchDefault
+ );
+
+ if (Services.policies?.status == Ci.nsIEnterprisePolicies.ACTIVE) {
+ let activePolicies = Services.policies.getActivePolicies();
+ if (activePolicies.SearchEngines) {
+ if (activePolicies.SearchEngines.Default) {
+ return this.#getEngineByName(activePolicies.SearchEngines.Default);
+ }
+ if (activePolicies.SearchEngines.Remove?.includes(defaultEngine.name)) {
+ defaultEngine = null;
+ }
+ }
+ }
+
+ if (defaultEngine) {
+ return defaultEngine;
+ }
+
+ if (privateMode) {
+ // If for some reason we can't find the private mode engine, fall back
+ // to the non-private one.
+ return this.#appDefaultEngine(false);
+ }
+
+ // Something unexpected has happened. In order to recover the app default
+ // engine, use the first visible engine that is also a general purpose engine.
+ // Worst case, we just use the first visible engine.
+ defaultEngine = this.#sortedVisibleEngines.find(
+ e => e.isGeneralPurposeEngine
+ );
+ return defaultEngine ? defaultEngine : this.#sortedVisibleEngines[0];
+ }
+
+ /**
+ * Loads engines asynchronously.
+ *
+ * @param {object} settings
+ * An object representing the search engine settings.
+ * @param {Array} engines
+ * An array containing the engines objects from remote settings.
+ * @param {object} privateDefault
+ * An object representing the private default search engine.
+ */
+ async #loadEngines(settings, engines, privateDefault) {
+ // Get user's current settings and search engine before we load engines from
+ // config. These values will be compared after engines are loaded.
+ let prevMetaData = { ...settings?.metaData };
+ let prevCurrentEngineId = prevMetaData.defaultEngineId;
+ let prevAppDefaultEngineId = prevMetaData?.appDefaultEngineId;
+
+ lazy.logConsole.debug("#loadEngines: start");
+ this.#setDefaultAndOrdersFromSelector(engines, privateDefault);
+
+ // We've done what we can without the add-on manager, now ensure that
+ // it has finished starting before we continue.
+ if (!lazy.SearchUtils.newSearchConfigEnabled) {
+ await lazy.AddonManager.readyPromise;
+ }
+
+ await this.#loadEnginesFromConfig(engines, settings);
+
+ await this.#loadStartupEngines(settings);
+
+ this.#loadEnginesFromPolicies(settings);
+
+ // `loadEnginesFromSettings` loads the engines and their settings together.
+ // If loading the settings caused the default engine to change because of an
+ // override, then we don't want to show the notification box.
+ let skipDefaultChangedNotification = await this.#loadEnginesFromSettings(
+ settings
+ );
+
+ // If #loadEnginesFromSettings changed the default engine, then we don't
+ // need to call #checkOpenSearchOverrides as we know that the overrides have
+ // only just been applied.
+ skipDefaultChangedNotification ||= await this.#checkOpenSearchOverrides(
+ settings
+ );
+
+ // Settings file version 6 and below will need a migration to store the
+ // engine ids rather than engine names.
+ this._settings.migrateEngineIds(settings);
+
+ lazy.logConsole.debug("#loadEngines: done");
+
+ let newCurrentEngine = this._getEngineDefault(false);
+ let newCurrentEngineId = newCurrentEngine?.id;
+
+ this._settings.setMetaDataAttribute(
+ "appDefaultEngineId",
+ this.appDefaultEngine?.id
+ );
+
+ if (
+ !skipDefaultChangedNotification &&
+ this.#shouldDisplayRemovalOfEngineNotificationBox(
+ settings,
+ prevMetaData,
+ newCurrentEngineId,
+ prevCurrentEngineId,
+ prevAppDefaultEngineId
+ )
+ ) {
+ let newCurrentEngineName = newCurrentEngine?.name;
+
+ let [prevCurrentEngineName, prevAppDefaultEngineName] = [
+ settings.engines.find(e => e.id == prevCurrentEngineId)?._name,
+ settings.engines.find(e => e.id == prevAppDefaultEngineId)?._name,
+ ];
+
+ this._showRemovalOfSearchEngineNotificationBox(
+ prevCurrentEngineName || prevAppDefaultEngineName,
+ newCurrentEngineName
+ );
+ }
+ }
+
+ /**
+ * Helper function to determine if the removal of search engine notification
+ * box should be displayed.
+ *
+ * @param { object } settings
+ * The user's search engine settings.
+ * @param { object } prevMetaData
+ * The user's previous search settings metadata.
+ * @param { object } newCurrentEngineId
+ * The user's new current default engine.
+ * @param { object } prevCurrentEngineId
+ * The user's previous default engine.
+ * @param { object } prevAppDefaultEngineId
+ * The user's previous app default engine.
+ * @returns { boolean }
+ * Return true if the previous default engine has been removed and
+ * notification box should be displayed.
+ */
+ #shouldDisplayRemovalOfEngineNotificationBox(
+ settings,
+ prevMetaData,
+ newCurrentEngineId,
+ prevCurrentEngineId,
+ prevAppDefaultEngineId
+ ) {
+ if (
+ !Services.prefs.getBoolPref("browser.search.removeEngineInfobar.enabled")
+ ) {
+ return false;
+ }
+
+ // If for some reason we were unable to install any engines and hence no
+ // default engine, do not display the notification box
+ if (!newCurrentEngineId) {
+ return false;
+ }
+
+ // If the previous engine is still available, don't show the notification
+ // box.
+ if (prevCurrentEngineId && this._engines.has(prevCurrentEngineId)) {
+ return false;
+ }
+ if (!prevCurrentEngineId && this._engines.has(prevAppDefaultEngineId)) {
+ return false;
+ }
+
+ // Don't show the notification if the previous engine was an enterprise engine -
+ // the text doesn't quite make sense.
+ // let checkPolicyEngineId = prevCurrentEngineId ? prevCurrentEngineId : prevAppDefaultEngineId;
+ let checkPolicyEngineId = prevCurrentEngineId || prevAppDefaultEngineId;
+ if (checkPolicyEngineId) {
+ let engineSettings = settings.engines.find(
+ e => e.id == checkPolicyEngineId
+ );
+ if (engineSettings?._loadPath?.startsWith("[policy]")) {
+ return false;
+ }
+ }
+
+ // If the user's previous engine id is different than the new current
+ // engine id, or if the user was using the app default engine and the
+ // app default engine id is different than the new current engine id,
+ // we check if the user's settings metadata has been upddated.
+ if (
+ (prevCurrentEngineId && prevCurrentEngineId !== newCurrentEngineId) ||
+ (!prevCurrentEngineId &&
+ prevAppDefaultEngineId &&
+ prevAppDefaultEngineId !== newCurrentEngineId)
+ ) {
+ // Check settings metadata to detect an update to locale. Sometimes when
+ // the user changes their locale it causes a change in engines.
+ // If there is no update to settings metadata then the engine change was
+ // caused by an update to config rather than a user changing their locale.
+ if (!this.#didSettingsMetaDataUpdate(prevMetaData)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Loads engines as specified by the configuration. We only expect
+ * configured engines here, user engines should not be listed.
+ *
+ * @param {Array} engineConfigs
+ * An array of engines configurations based on the schema.
+ * @param {object} [settings]
+ * The saved settings for the user.
+ */
+ async #loadEnginesFromConfig(engineConfigs, settings) {
+ lazy.logConsole.debug("#loadEnginesFromConfig");
+ for (let config of engineConfigs) {
+ try {
+ let engine = await this._makeEngineFromConfig(config, settings);
+ this.#addEngineToStore(engine);
+ } catch (ex) {
+ console.error(
+ `Could not load engine ${
+ "webExtension" in config ? config.webExtension.id : "unknown"
+ }: ${ex}`
+ );
+ }
+ }
+ }
+
+ /**
+ * Loads any engines that have been received from the AddonManager during
+ * startup and before we have finished initialising.
+ *
+ * @param {object} [settings]
+ * The saved settings for the user.
+ */
+ async #loadStartupEngines(settings) {
+ if (
+ this.#startupExtensions.size &&
+ lazy.SearchUtils.newSearchConfigEnabled
+ ) {
+ await lazy.AddonManager.readyPromise;
+ }
+
+ lazy.logConsole.debug(
+ "#loadEngines: loading",
+ this.#startupExtensions.size,
+ "engines reported by AddonManager startup"
+ );
+ for (let extension of this.#startupExtensions) {
+ try {
+ await this.#installExtensionEngine(
+ extension,
+ [lazy.SearchUtils.DEFAULT_TAG],
+ settings,
+ true
+ );
+ } catch (ex) {
+ lazy.logConsole.error(
+ `#installExtensionEngine failed for ${extension.id}`,
+ ex
+ );
+ }
+ }
+ this.#startupExtensions.clear();
+ }
+
+ /**
+ * When starting up, check if any of the saved application provided engines
+ * are no longer required, previously were default and were overridden by
+ * an OpenSearch engine.
+ *
+ * Also check if any OpenSearch overrides need to be re-applied.
+ *
+ * Add-on search engines are handled separately.
+ *
+ * @param {object} settings
+ * The loaded settings for the user.
+ * @returns {boolean}
+ * Returns true if the default engine was changed.
+ */
+ async #checkOpenSearchOverrides(settings) {
+ let defaultEngineChanged = false;
+ let savedDefaultEngineId =
+ settings.metaData.defaultEngineId || settings.metaData.appDefaultEngineId;
+ if (!savedDefaultEngineId) {
+ return false;
+ }
+ // First handle the case where the application provided engine was removed,
+ // and we need to restore the OpenSearch engine.
+ for (let engineSettings of settings.engines) {
+ if (
+ !this._engines.get(engineSettings.id) &&
+ engineSettings._isAppProvided &&
+ engineSettings.id == savedDefaultEngineId &&
+ engineSettings._metaData.overriddenByOpenSearch
+ ) {
+ let restoringEngine = new lazy.OpenSearchEngine({
+ json: engineSettings._metaData.overriddenByOpenSearch,
+ });
+ restoringEngine.copyUserSettingsFrom(engineSettings);
+ this.#addEngineToStore(restoringEngine, true);
+
+ // We assume that the app provided engine was removed due to a
+ // configuration change, and therefore we have re-added the OpenSearch
+ // search engine. It is possible that it was actually due to a
+ // locale/region change, but that is harder to detect here.
+ this.#setEngineDefault(
+ false,
+ restoringEngine,
+ Ci.nsISearchService.CHANGE_REASON_CONFIG
+ );
+ delete engineSettings._metaData.overriddenByOpenSearch;
+ }
+ }
+ // Now handle the case where the an application provided engine has been
+ // overridden by an OpenSearch engine, and we need to re-apply the override.
+ for (let engine of this._engines.values()) {
+ if (
+ engine.isAppProvided &&
+ engine.getAttr("overriddenByOpenSearch") &&
+ engine.id == savedDefaultEngineId
+ ) {
+ let restoringEngine = new lazy.OpenSearchEngine({
+ json: engine.getAttr("overriddenByOpenSearch"),
+ });
+ if (
+ await lazy.defaultOverrideAllowlist.canEngineOverride(
+ restoringEngine,
+ engine._extensionID
+ )
+ ) {
+ engine.overrideWithEngine({ engine: restoringEngine });
+ }
+ }
+ }
+
+ return defaultEngineChanged;
+ }
+
+ /**
+ * Reloads engines asynchronously, but only when
+ * the service has already been initialized.
+ *
+ * This is prefixed with _ rather than # because it is
+ * called in test_reload_engines.js
+ *
+ * @param {integer} changeReason
+ * The reason reload engines is being called, one of
+ * Ci.nsISearchService.CHANGE_REASON*
+ */
+ async _maybeReloadEngines(changeReason) {
+ if (this.#maybeReloadDebounce) {
+ lazy.logConsole.debug("We're already waiting to reload engines.");
+ return;
+ }
+
+ if (!this.isInitialized || this._reloadingEngines) {
+ this.#maybeReloadDebounce = true;
+ // Schedule a reload to happen at most 10 seconds after the current run.
+ Services.tm.idleDispatchToMainThread(() => {
+ if (!this.#maybeReloadDebounce) {
+ return;
+ }
+ this.#maybeReloadDebounce = false;
+ this._maybeReloadEngines(changeReason).catch(console.error);
+ }, 10000);
+ lazy.logConsole.debug(
+ "Post-poning maybeReloadEngines() as we're currently initializing."
+ );
+ return;
+ }
+
+ // Before entering `_reloadingEngines` get the settings which we'll need.
+ // This also ensures that any pending settings have finished being written,
+ // which could otherwise cause data loss.
+ let settings = await this._settings.get();
+
+ lazy.logConsole.debug("Running maybeReloadEngines");
+ this._reloadingEngines = true;
+
+ try {
+ await this._reloadEngines(settings, changeReason);
+ } catch (ex) {
+ lazy.logConsole.error("maybeReloadEngines failed", ex);
+ }
+ this._reloadingEngines = false;
+ lazy.logConsole.debug("maybeReloadEngines complete");
+ }
+
+ /**
+ * Manages reloading of the search engines when something in the user's
+ * environment or the configuration has changed.
+ *
+ * The order of work here is designed to avoid potential issues when updating
+ * the default engines, so that we're not removing active defaults or trying
+ * to set a default to something that hasn't been added yet. The order is:
+ *
+ * 1) Update exising engines that are in both the old and new configuration.
+ * 2) Add any new engines from the new configuration.
+ * 3) Check for changes needed to the default engines due to environment changes
+ * and potentially overriding engines as per the override allowlist.
+ * 4) Update the default engines.
+ * 5) Remove any old engines.
+ *
+ * This is prefixed with _ rather than # because it is called in
+ * test_remove_engine_notification_box.js
+ *
+ * @param {object} settings
+ * The user's current saved settings.
+ * @param {integer} changeReason
+ * The reason reload engines is being called, one of
+ * Ci.nsISearchService.CHANGE_REASON*
+ */
+ async _reloadEngines(settings, changeReason) {
+ // Capture the current engine state, in case we need to notify below.
+ let prevCurrentEngine = this.#currentEngine;
+ let prevPrivateEngine = this.#currentPrivateEngine;
+ let prevMetaData = { ...settings?.metaData };
+
+ // Ensure that we don't set the useSavedOrder flag whilst we're doing this.
+ // This isn't a user action, so we shouldn't be switching it.
+ this.#dontSetUseSavedOrder = true;
+
+ let { engines: appDefaultConfigEngines, privateDefault } =
+ await this._fetchEngineSelectorEngines();
+
+ let configEngines = [...appDefaultConfigEngines];
+ let oldEngineList = [...this._engines.values()];
+
+ for (let engine of oldEngineList) {
+ if (!engine.isAppProvided) {
+ if (engine instanceof lazy.AddonSearchEngine) {
+ // If this is an add-on search engine, check to see if it needs
+ // an update.
+ await engine.update();
+ }
+ continue;
+ }
+
+ let index = configEngines.findIndex(
+ e =>
+ e.webExtension.id == engine._extensionID &&
+ e.webExtension.locale == engine._locale
+ );
+
+ if (index == -1) {
+ // No engines directly match on id and locale, however, check to see
+ // if we have a new entry that matches on id and name - we might just
+ // be swapping the in-use locale.
+ let replacementEngines = configEngines.filter(
+ e => e.webExtension.id == engine._extensionID
+ );
+ // If there's no possible, or more than one, we treat these as distinct
+ // engines so we'll remove the existing engine and add new later if
+ // necessary.
+ if (replacementEngines.length != 1) {
+ engine.pendingRemoval = true;
+ continue;
+ }
+
+ // Update the index so we can handle the updating below.
+ index = configEngines.findIndex(
+ e =>
+ e.webExtension.id == replacementEngines[0].webExtension.id &&
+ e.webExtension.locale == replacementEngines[0].webExtension.locale
+ );
+ let locale =
+ replacementEngines[0].webExtension.locale ||
+ lazy.SearchUtils.DEFAULT_TAG;
+
+ // If the name is different, then we must treat the engine as different,
+ // and go through the remove and add cycle, rather than modifying the
+ // existing one.
+ let hasUpdated = await engine.updateIfNoNameChange({
+ configuration: configEngines[index],
+ locale,
+ });
+ if (!hasUpdated) {
+ // No matching name, so just remove it.
+ engine.pendingRemoval = true;
+ continue;
+ }
+ } else {
+ // This is an existing engine that we should update (we don't know if
+ // the configuration for this engine has changed or not).
+ await engine.update({
+ configuration: configEngines[index],
+ locale: engine._locale,
+ });
+ }
+
+ configEngines.splice(index, 1);
+ }
+
+ let existingDuplicateEngines = [];
+
+ // Any remaining configuration engines are ones that we need to add.
+ for (let engine of configEngines) {
+ try {
+ let newAppEngine = await this._makeEngineFromConfig(engine, settings);
+
+ // If this is a duplicate name, keep track of the old engine as we need
+ // to handle it later.
+ let duplicateEngine = this.#getEngineByName(newAppEngine.name);
+ if (duplicateEngine) {
+ existingDuplicateEngines.push({
+ duplicateEngine,
+ newAppEngine,
+ });
+ }
+ // We add our new engine to the store anyway, as we know it is an
+ // application provided engine which will take priority over the
+ // duplicate.
+ this.#addEngineToStore(newAppEngine, true);
+ } catch (ex) {
+ lazy.logConsole.warn(
+ `Could not load engine ${
+ "webExtension" in engine ? engine.webExtension.id : "unknown"
+ }: ${ex}`
+ );
+ }
+ }
+
+ // Now set the sort out the default engines and notify as appropriate.
+
+ // Clear the current values, so that we'll completely reset.
+ this.#currentEngine = null;
+ this.#currentPrivateEngine = null;
+
+ // If the user's default is one of the private engines that is being removed,
+ // reset the stored setting, so that we correctly detect the change in
+ // in default.
+ if (prevCurrentEngine?.pendingRemoval) {
+ this._settings.setMetaDataAttribute("defaultEngineId", "");
+ }
+ if (prevPrivateEngine?.pendingRemoval) {
+ this._settings.setMetaDataAttribute("privateDefaultEngineId", "");
+ }
+
+ this.#setDefaultAndOrdersFromSelector(
+ appDefaultConfigEngines,
+ privateDefault
+ );
+
+ let skipDefaultChangedNotification = false;
+
+ for (let { duplicateEngine, newAppEngine } of existingDuplicateEngines) {
+ if (prevCurrentEngine && prevCurrentEngine == duplicateEngine) {
+ if (
+ await lazy.defaultOverrideAllowlist.canEngineOverride(
+ duplicateEngine,
+ newAppEngine?._extensionID
+ )
+ ) {
+ lazy.logConsole.log(
+ "Applying override from",
+ duplicateEngine.id,
+ "to application engine",
+ newAppEngine._extensionID,
+ "and setting app engine default"
+ );
+ // This engine was default, and is allowed to override our application
+ // provided engines, so update the application engine and set it as
+ // default.
+ newAppEngine.overrideWithEngine({
+ engine: duplicateEngine,
+ });
+
+ this.defaultEngine = newAppEngine;
+ // We're removing the old engine and we've changed the default, but this
+ // is intentional and effectively everything is the same for the user, so
+ // don't notify.
+ skipDefaultChangedNotification = true;
+ }
+ }
+ duplicateEngine.pendingRemoval = true;
+ }
+
+ if (prevCurrentEngine && prevCurrentEngine.pendingRemoval) {
+ skipDefaultChangedNotification ||=
+ await this.#maybeRestoreEngineFromOverride(prevCurrentEngine);
+ }
+
+ // If the defaultEngine has changed between the previous load and this one,
+ // dispatch the appropriate notifications.
+ if (prevCurrentEngine && this.defaultEngine !== prevCurrentEngine) {
+ this.#recordDefaultChangedEvent(
+ false,
+ prevCurrentEngine,
+ this.defaultEngine,
+ changeReason
+ );
+ lazy.SearchUtils.notifyAction(
+ this.#currentEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.DEFAULT
+ );
+ // If we've not got a separate private active, notify update of the
+ // private so that the UI updates correctly.
+ if (!this.#separatePrivateDefault) {
+ lazy.SearchUtils.notifyAction(
+ this.#currentEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.DEFAULT_PRIVATE
+ );
+ }
+
+ if (
+ !skipDefaultChangedNotification &&
+ prevMetaData &&
+ settings.metaData &&
+ !this.#didSettingsMetaDataUpdate(prevMetaData) &&
+ prevCurrentEngine?.pendingRemoval &&
+ Services.prefs.getBoolPref("browser.search.removeEngineInfobar.enabled")
+ ) {
+ this._showRemovalOfSearchEngineNotificationBox(
+ prevCurrentEngine.name,
+ this.defaultEngine.name
+ );
+ }
+ }
+
+ if (
+ this.#separatePrivateDefault &&
+ prevPrivateEngine &&
+ this.defaultPrivateEngine !== prevPrivateEngine
+ ) {
+ this.#recordDefaultChangedEvent(
+ true,
+ prevPrivateEngine,
+ this.defaultPrivateEngine,
+ changeReason
+ );
+ lazy.SearchUtils.notifyAction(
+ this.#currentPrivateEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.DEFAULT_PRIVATE
+ );
+ }
+
+ // Finally, remove any engines that need removing. We do this after sorting
+ // out the new default, as otherwise this could cause multiple notifications
+ // and the wrong engine to be selected as default.
+
+ for (let engine of this._engines.values()) {
+ if (!engine.pendingRemoval) {
+ continue;
+ }
+
+ // If we have other engines that use the same extension ID, then
+ // we do not want to remove the add-on - only remove the engine itself.
+ let inUseEngines = [...this._engines.values()].filter(
+ e => e._extensionID == engine._extensionID
+ );
+
+ if (inUseEngines.length <= 1) {
+ if (inUseEngines.length == 1 && inUseEngines[0] == engine) {
+ // No other engines are using this extension ID.
+
+ // The internal remove is done first to avoid a call to removeEngine
+ // which could adjust the sort order when we don't want it to.
+ this.#internalRemoveEngine(engine);
+
+ // Only uninstall application provided engines. We don't want to
+ // remove third-party add-ons. Their search engine names might conflict,
+ // but we still allow the add-on to be installed.
+ if (engine.isAppProvided) {
+ let addon = await lazy.AddonManager.getAddonByID(
+ engine._extensionID
+ );
+ if (addon) {
+ // AddonManager won't call removeEngine if an engine with the
+ // WebExtension id doesn't exist in the search service.
+ await addon.uninstall();
+ }
+ }
+ }
+ // For the case where `inUseEngines[0] != engine`:
+ // This is a situation where there was an engine added earlier in this
+ // function with the same name.
+ // For example, eBay has the same name for both US and GB, but has
+ // a different domain and uses a different locale of the same
+ // WebExtension.
+ // The result of this is the earlier addition has already replaced
+ // the engine in `this._engines` (which is indexed by name), so all that
+ // needs to be done here is to pretend the old engine was removed
+ // which is notified below.
+ } else {
+ // More than one engine is using this extension ID, so we don't want to
+ // remove the add-on.
+ this.#internalRemoveEngine(engine);
+ }
+ lazy.SearchUtils.notifyAction(
+ engine,
+ lazy.SearchUtils.MODIFIED_TYPE.REMOVED
+ );
+ }
+
+ // Save app default engine to the user's settings metaData incase it has
+ // been updated
+ this._settings.setMetaDataAttribute(
+ "appDefaultEngineId",
+ this.appDefaultEngine?.id
+ );
+
+ // If we are leaving an experiment, and the default is the same as the
+ // application default, we reset the user's setting to blank, so that
+ // future changes of the application default engine may take effect.
+ if (
+ prevMetaData.experiment &&
+ !this._settings.getMetaDataAttribute("experiment")
+ ) {
+ if (this.defaultEngine == this.appDefaultEngine) {
+ this._settings.setVerifiedMetaDataAttribute("defaultEngineId", "");
+ }
+ if (
+ this.#separatePrivateDefault &&
+ this.defaultPrivateEngine == this.appPrivateDefaultEngine
+ ) {
+ this._settings.setVerifiedMetaDataAttribute(
+ "privateDefaultEngineId",
+ ""
+ );
+ }
+ }
+
+ this.#dontSetUseSavedOrder = false;
+ // Clear out the sorted engines settings, so that we re-sort it if necessary.
+ this._cachedSortedEngines = null;
+ Services.obs.notifyObservers(
+ null,
+ lazy.SearchUtils.TOPIC_SEARCH_SERVICE,
+ "engines-reloaded"
+ );
+ }
+
+ /**
+ * Potentially restores an engine if it was previously overriding the app
+ * provided engine.
+ *
+ * @param {SearchEngine} prevCurrentEngine
+ * The previous current engine to check for override.
+ * @returns {boolean}
+ * True if an engine was restored.
+ */
+ async #maybeRestoreEngineFromOverride(prevCurrentEngine) {
+ let overriddenBy = prevCurrentEngine.getAttr("overriddenBy");
+ if (!overriddenBy) {
+ return false;
+ }
+ let overriddenByOpenSearch = prevCurrentEngine.getAttr(
+ "overriddenByOpenSearch"
+ );
+ let engine;
+ if (overriddenByOpenSearch) {
+ engine = new lazy.OpenSearchEngine({
+ json: overriddenByOpenSearch,
+ });
+ } else {
+ // The previous application default engine is being removed, and it was
+ // overridden by another engine. We want to put the previous engine back,
+ // so that the user retains that engine as default.
+ engine = new lazy.AddonSearchEngine({
+ isAppProvided: false,
+ details: {
+ extensionID: overriddenBy,
+ locale: lazy.SearchUtils.DEFAULT_TAG,
+ },
+ });
+ try {
+ await engine.init({ locale: lazy.SearchUtils.DEFAULT_TAG });
+ } catch (ex) {
+ // If there is an error, the add-on may no longer be available, or
+ // there was some other issue with the settings.
+ lazy.logConsole.error(
+ "Error restoring overridden engine",
+ overriddenBy,
+ ex
+ );
+ return false;
+ }
+ }
+ engine.copyUserSettingsFrom(prevCurrentEngine);
+ this.#addEngineToStore(engine, true);
+
+ // Now set it back to default.
+ this.defaultEngine = engine;
+ return true;
+ }
+
+ #addEngineToStore(engine, skipDuplicateCheck = false) {
+ if (this.#engineMatchesIgnoreLists(engine)) {
+ lazy.logConsole.debug("#addEngineToStore: Ignoring engine");
+ return;
+ }
+
+ lazy.logConsole.debug("#addEngineToStore: Adding engine:", engine.name);
+
+ // See if there is an existing engine with the same name.
+ if (!skipDuplicateCheck && this.#getEngineByName(engine.name)) {
+ throw Components.Exception(
+ `#addEngineToStore: An engine called ${engine.name} already exists!`,
+ Cr.NS_ERROR_FILE_ALREADY_EXISTS
+ );
+ }
+
+ // Not an update, just add the new engine.
+ this._engines.set(engine.id, engine);
+ // Only add the engine to the list of sorted engines if the initial list
+ // has already been built (i.e. if this._cachedSortedEngines is non-null). If
+ // it hasn't, we're loading engines from disk and the sorted engine list
+ // will be built once we need it.
+ if (this._cachedSortedEngines && !this.#dontSetUseSavedOrder) {
+ this._cachedSortedEngines.push(engine);
+ this.#saveSortedEngineList();
+ }
+ lazy.SearchUtils.notifyAction(engine, lazy.SearchUtils.MODIFIED_TYPE.ADDED);
+
+ // Let the engine know it can start notifying new updates.
+ engine._engineAddedToStore = true;
+ }
+
+ /**
+ * Loads any search engines specified by enterprise policies.
+ *
+ * @param {object} [settings]
+ * The saved settings for the user.
+ */
+ #loadEnginesFromPolicies(settings) {
+ if (Services.policies?.status != Ci.nsIEnterprisePolicies.ACTIVE) {
+ return;
+ }
+
+ let activePolicies = Services.policies.getActivePolicies();
+ if (!activePolicies.SearchEngines) {
+ return;
+ }
+ for (let engineDetails of activePolicies.SearchEngines.Add ?? []) {
+ this.#addPolicyEngine(engineDetails, settings);
+ }
+ }
+
+ /**
+ * Loads remaining user search engines from settings.
+ *
+ * @param {object} [settings]
+ * The saved settings for the user.
+ * @returns {boolean}
+ * Returns true if the default engine was changed.
+ */
+ async #loadEnginesFromSettings(settings) {
+ if (!settings.engines) {
+ return false;
+ }
+
+ lazy.logConsole.debug(
+ "#loadEnginesFromSettings: Loading",
+ settings.engines.length,
+ "engines from settings"
+ );
+
+ let defaultEngineChanged = false;
+ let skippedEngines = 0;
+ for (let engineJSON of settings.engines) {
+ // We renamed isBuiltin to isAppProvided in bug 1631898,
+ // keep checking isBuiltin for older settings.
+ if (engineJSON._isAppProvided || engineJSON._isBuiltin) {
+ ++skippedEngines;
+ continue;
+ }
+
+ // Some OpenSearch type engines are now obsolete and no longer supported.
+ // These were application provided engines that used to use the OpenSearch
+ // format before gecko transitioned to WebExtensions.
+ // These will sometimes have been missed in migration due to various
+ // reasons, and due to how the settings saves everything. We therefore
+ // explicitly ignore them here to drop them, and let the rest of the code
+ // fallback to the application/distribution default if necessary.
+ let loadPath = engineJSON._loadPath?.toLowerCase();
+ if (
+ loadPath &&
+ // Replaced by application provided in Firefox 79.
+ (loadPath.startsWith("[distribution]") ||
+ // Langpack engines moved in-app in Firefox 62.
+ // Note: these may be prefixed by jar:,
+ loadPath.includes("[app]/extensions/langpack") ||
+ loadPath.includes("[other]/langpack") ||
+ loadPath.includes("[profile]/extensions/langpack") ||
+ // Old omni.ja engines also moved to in-app in Firefox 62.
+ loadPath.startsWith("jar:[app]/omni.ja"))
+ ) {
+ continue;
+ }
+
+ try {
+ let engine;
+ if (loadPath?.startsWith("[policy]")) {
+ skippedEngines++;
+ continue;
+ } else if (loadPath?.startsWith("[user]")) {
+ engine = new lazy.UserSearchEngine({ json: engineJSON });
+ } else if (engineJSON.extensionID ?? engineJSON._extensionID) {
+ engine = new lazy.AddonSearchEngine({
+ isAppProvided: false,
+ json: engineJSON,
+ });
+ } else {
+ engine = new lazy.OpenSearchEngine({
+ json: engineJSON,
+ });
+ }
+ // Only check the override for Add-on or OpenSearch engines, and only
+ // if they are the default engine.
+ if (
+ (engine instanceof lazy.OpenSearchEngine ||
+ engine instanceof lazy.AddonSearchEngine) &&
+ settings.metaData?.defaultEngineId == engine.id
+ ) {
+ defaultEngineChanged = await this.#maybeApplyOverride(engine);
+ if (defaultEngineChanged) {
+ continue;
+ }
+ }
+ this.#addEngineToStore(engine);
+ } catch (ex) {
+ lazy.logConsole.error(
+ "Failed to load",
+ engineJSON._name,
+ "from settings:",
+ ex,
+ engineJSON
+ );
+ }
+ }
+
+ if (skippedEngines) {
+ lazy.logConsole.debug(
+ "#loadEnginesFromSettings: skipped",
+ skippedEngines,
+ "built-in/policy engines."
+ );
+ }
+ return defaultEngineChanged;
+ }
+
+ /**
+ * Looks to see if an override may be applied to an application engine
+ * if the supplied engine is a duplicate of it. This should only be called
+ * in the case where the engine would become the default engine.
+ *
+ * @param {SearchEngine} engine
+ * The search engine to check to see if it should override an existing engine.
+ * @returns {boolean}
+ * True if the default engine was changed.
+ */
+ async #maybeApplyOverride(engine) {
+ // If an engine with the same name already exists, we're not going to
+ // be allowed to add it - however, if it is default, and it
+ // matches an existing engine, then we might be allowed to
+ // override the application provided engine.
+ let existingEngine = this.#getEngineByName(engine.name);
+ if (
+ existingEngine?.isAppProvided &&
+ (await lazy.defaultOverrideAllowlist.canEngineOverride(
+ engine,
+ existingEngine?._extensionID
+ ))
+ ) {
+ existingEngine.overrideWithEngine({
+ engine,
+ });
+ this.#setEngineDefault(
+ false,
+ existingEngine,
+ // We assume that the application provided engine was added due
+ // to a configuration change. It is possible that it was actually
+ // due to a locale/region change, but that is harder to detect
+ // here.
+ Ci.nsISearchService.CHANGE_REASON_CONFIG
+ );
+ return true;
+ }
+ return false;
+ }
+
+ // This is prefixed with _ rather than # because it is
+ // called in test_remove_engine_notification_box.js
+ async _fetchEngineSelectorEngines() {
+ let searchEngineSelectorProperties = {
+ locale: Services.locale.appLocaleAsBCP47,
+ region: lazy.Region.home || "default",
+ channel: lazy.SearchUtils.MODIFIED_APP_CHANNEL,
+ experiment:
+ lazy.NimbusFeatures.searchConfiguration.getVariable("experiment") ?? "",
+ distroID: lazy.SearchUtils.distroID ?? "",
+ };
+
+ for (let [key, value] of Object.entries(searchEngineSelectorProperties)) {
+ this._settings.setMetaDataAttribute(key, value);
+ }
+
+ let { engines, privateDefault } =
+ await this.#engineSelector.fetchEngineConfiguration(
+ searchEngineSelectorProperties
+ );
+
+ for (let e of engines) {
+ if (!e.webExtension) {
+ e.webExtension = {};
+ }
+ e.webExtension.locale =
+ e.webExtension?.locale ?? lazy.SearchUtils.DEFAULT_TAG;
+
+ // TODO Bug 1875912 - Remove the webextension.id and webextension.locale when
+ // we're ready to remove old search-config and use search-config-v2 for all
+ // clients. The id in appProvidedSearchEngine should be changed to
+ // engine.identifier.
+ if (lazy.SearchUtils.newSearchConfigEnabled) {
+ let identifierComponents = NON_SPLIT_ENGINE_IDS.includes(e.identifier)
+ ? [e.identifier]
+ : e.identifier.split("-");
+
+ if (e.identifier == "amazon-se") {
+ identifierComponents[1] = "sweden";
+ }
+
+ if (e.identifier == "amazon-es") {
+ identifierComponents[1] = "spain";
+ }
+
+ let locale = identifierComponents.slice(1).join("-") || "default";
+
+ e.webExtension.id = identifierComponents[0] + "@search.mozilla.org";
+ e.webExtension.locale = locale;
+ }
+ }
+
+ return { engines, privateDefault };
+ }
+
+ #setDefaultAndOrdersFromSelector(engines, privateDefault) {
+ const defaultEngine = engines[0];
+ this._searchDefault = {
+ id: defaultEngine.webExtension.id,
+ locale: defaultEngine.webExtension.locale,
+ };
+ if (privateDefault) {
+ this.#searchPrivateDefault = {
+ id: privateDefault.webExtension.id,
+ locale: privateDefault.webExtension.locale,
+ };
+ }
+ }
+
+ #saveSortedEngineList() {
+ lazy.logConsole.debug("#saveSortedEngineList");
+
+ // Set the useSavedOrder attribute to indicate that from now on we should
+ // use the user's order information stored in settings.
+ this._settings.setMetaDataAttribute("useSavedOrder", true);
+
+ var engines = this.#sortedEngines;
+
+ for (var i = 0; i < engines.length; ++i) {
+ engines[i].setAttr("order", i + 1);
+ }
+ }
+
+ #buildSortedEngineList() {
+ // We must initialise _cachedSortedEngines here to avoid infinite recursion
+ // in the case of tests which don't define a default search engine.
+ // If there's no default defined, then we revert to the first item in the
+ // sorted list, but we can't do that if we don't have a list.
+ this._cachedSortedEngines = [];
+
+ // If the user has specified a custom engine order, read the order
+ // information from the metadata instead of the default prefs.
+ if (this._settings.getMetaDataAttribute("useSavedOrder")) {
+ lazy.logConsole.debug("#buildSortedEngineList: using saved order");
+ let addedEngines = {};
+
+ // Flag to keep track of whether or not we need to call #saveSortedEngineList.
+ let needToSaveEngineList = false;
+
+ for (let engine of this._engines.values()) {
+ var orderNumber = engine.getAttr("order");
+
+ // Since the DB isn't regularly cleared, and engine files may disappear
+ // without us knowing, we may already have an engine in this slot. If
+ // that happens, we just skip it - it will be added later on as an
+ // unsorted engine.
+ if (orderNumber && !this._cachedSortedEngines[orderNumber - 1]) {
+ this._cachedSortedEngines[orderNumber - 1] = engine;
+ addedEngines[engine.name] = engine;
+ } else {
+ // We need to call #saveSortedEngineList so this gets sorted out.
+ needToSaveEngineList = true;
+ }
+ }
+
+ // Filter out any nulls for engines that may have been removed
+ var filteredEngines = this._cachedSortedEngines.filter(function (a) {
+ return !!a;
+ });
+ if (this._cachedSortedEngines.length != filteredEngines.length) {
+ needToSaveEngineList = true;
+ }
+ this._cachedSortedEngines = filteredEngines;
+
+ if (needToSaveEngineList) {
+ this.#saveSortedEngineList();
+ }
+
+ // Array for the remaining engines, alphabetically sorted.
+ let alphaEngines = [];
+
+ for (let engine of this._engines.values()) {
+ if (!(engine.name in addedEngines)) {
+ alphaEngines.push(engine);
+ }
+ }
+
+ const collator = new Intl.Collator();
+ alphaEngines.sort((a, b) => {
+ return collator.compare(a.name, b.name);
+ });
+ return (this._cachedSortedEngines =
+ this._cachedSortedEngines.concat(alphaEngines));
+ }
+ lazy.logConsole.debug("#buildSortedEngineList: using default orders");
+
+ return (this._cachedSortedEngines = this._sortEnginesByDefaults(
+ Array.from(this._engines.values())
+ ));
+ }
+
+ /**
+ * Sorts engines by the default settings (prefs, configuration values).
+ *
+ * @param {Array} engines
+ * An array of engine objects to sort.
+ * @returns {Array}
+ * The sorted array of engine objects.
+ *
+ * This is a private method with _ rather than # because it is
+ * called in a test.
+ */
+ _sortEnginesByDefaults(engines) {
+ const sortedEngines = [];
+ const addedEngines = new Set();
+
+ function maybeAddEngineToSort(engine) {
+ if (!engine || addedEngines.has(engine.name)) {
+ return;
+ }
+
+ sortedEngines.push(engine);
+ addedEngines.add(engine.name);
+ }
+
+ // The app default engine should always be first in the list (except
+ // for distros, that we should respect).
+ const appDefault = this.appDefaultEngine;
+ maybeAddEngineToSort(appDefault);
+
+ // If there's a private default, and it is different to the normal
+ // default, then it should be second in the list.
+ const appPrivateDefault = this.appPrivateDefaultEngine;
+ if (appPrivateDefault && appPrivateDefault != appDefault) {
+ maybeAddEngineToSort(appPrivateDefault);
+ }
+
+ let remainingEngines;
+ const collator = new Intl.Collator();
+
+ remainingEngines = engines.filter(e => !addedEngines.has(e.name));
+
+ // We sort by highest orderHint first, then alphabetically by name.
+ remainingEngines.sort((a, b) => {
+ if (a._orderHint && b._orderHint) {
+ if (a._orderHint == b._orderHint) {
+ return collator.compare(a.name, b.name);
+ }
+ return b._orderHint - a._orderHint;
+ }
+ if (a._orderHint) {
+ return -1;
+ }
+ if (b._orderHint) {
+ return 1;
+ }
+ return collator.compare(a.name, b.name);
+ });
+
+ return [...sortedEngines, ...remainingEngines];
+ }
+
+ /**
+ * Get a sorted array of the visible engines.
+ *
+ * @returns {Array<SearchEngine>}
+ */
+
+ get #sortedVisibleEngines() {
+ return this.#sortedEngines.filter(engine => !engine.hidden);
+ }
+
+ /**
+ * Migrates legacy add-ons which used the OpenSearch definitions to
+ * WebExtensions, if an equivalent WebExtension is installed.
+ *
+ * Run during the background checks.
+ */
+ async #migrateLegacyEngines() {
+ lazy.logConsole.debug("Running migrate legacy engines");
+
+ const matchRegExp = /extensions\/(.*?)\.xpi!/i;
+ for (let engine of this._engines.values()) {
+ if (
+ !engine.isAppProvided &&
+ !engine._extensionID &&
+ engine._loadPath.includes("[profile]/extensions/")
+ ) {
+ let match = engine._loadPath.match(matchRegExp);
+ if (match?.[1]) {
+ // There's a chance here that the WebExtension might not be
+ // installed any longer, even though the engine is. We'll deal
+ // with that in `checkWebExtensionEngines`.
+ let engines = await this.getEnginesByExtensionID(match[1]);
+ if (engines.length) {
+ lazy.logConsole.debug(
+ `Migrating ${engine.name} to WebExtension install`
+ );
+
+ if (this.defaultEngine == engine) {
+ this.defaultEngine = engines[0];
+ }
+ await this.removeEngine(engine);
+ }
+ }
+ }
+ }
+
+ lazy.logConsole.debug("Migrate legacy engines complete");
+ }
+
+ /**
+ * Checks if Search Engines associated with WebExtensions are valid and
+ * up-to-date, and reports them via telemetry if not.
+ *
+ * Run during the background checks.
+ */
+ async #checkWebExtensionEngines() {
+ lazy.logConsole.debug("Running check on WebExtension engines");
+
+ for (let engine of this._engines.values()) {
+ if (engine instanceof lazy.AddonSearchEngine && !engine.isAppProvided) {
+ await engine.checkAndReportIfSettingsValid();
+ }
+ }
+ lazy.logConsole.debug("WebExtension engine check complete");
+ }
+
+ /**
+ * Counts the number of secure, insecure, securely updated and insecurely
+ * updated OpenSearch engines the user has installed and reports those
+ * counts via telemetry.
+ *
+ * Run during the background checks.
+ */
+ async #addOpenSearchTelemetry() {
+ let totalSecure = 0;
+ let totalInsecure = 0;
+ let totalWithSecureUpdates = 0;
+ let totalWithInsecureUpdates = 0;
+
+ let engine;
+ let searchURI;
+ let updateURI;
+ for (let elem of this._engines) {
+ engine = elem[1];
+ if (engine instanceof lazy.OpenSearchEngine) {
+ searchURI = engine.searchURLWithNoTerms;
+ updateURI = engine.updateURI;
+
+ if (lazy.SearchUtils.isSecureURIForOpenSearch(searchURI)) {
+ totalSecure++;
+ } else {
+ totalInsecure++;
+ }
+
+ if (updateURI && lazy.SearchUtils.isSecureURIForOpenSearch(updateURI)) {
+ totalWithSecureUpdates++;
+ } else if (updateURI) {
+ totalWithInsecureUpdates++;
+ }
+ }
+ }
+
+ Services.telemetry.scalarSet(
+ "browser.searchinit.secure_opensearch_engine_count",
+ totalSecure
+ );
+ Services.telemetry.scalarSet(
+ "browser.searchinit.insecure_opensearch_engine_count",
+ totalInsecure
+ );
+ Services.telemetry.scalarSet(
+ "browser.searchinit.secure_opensearch_update_count",
+ totalWithSecureUpdates
+ );
+ Services.telemetry.scalarSet(
+ "browser.searchinit.insecure_opensearch_update_count",
+ totalWithInsecureUpdates
+ );
+ }
+
+ /**
+ * Creates and adds a WebExtension based engine.
+ *
+ * @param {object} options
+ * Options for the engine.
+ * @param {Extension} options.extension
+ * An Extension object containing data about the extension.
+ * @param {string} [options.locale]
+ * The locale to use within the WebExtension. Defaults to the WebExtension's
+ * default locale.
+ * @param {object} [options.settings]
+ * The saved settings for the user.
+ * @param {initEngine} [options.initEngine]
+ * Set to true if this engine is being loaded during initialization.
+ */
+ async _createAndAddEngine({
+ extension,
+ locale = lazy.SearchUtils.DEFAULT_TAG,
+ settings,
+ initEngine = false,
+ }) {
+ // If we're in the startup cycle, and we've already loaded this engine,
+ // then we use the existing one rather than trying to start from scratch.
+ // This also avoids console errors.
+ if (extension.startupReason == "APP_STARTUP") {
+ let engine = this.#getEngineByWebExtensionDetails({
+ id: extension.id,
+ locale,
+ });
+ if (engine) {
+ lazy.logConsole.debug(
+ "Engine already loaded via settings, skipping due to APP_STARTUP:",
+ extension.id
+ );
+ return engine;
+ }
+ }
+
+ // We install search extensions during the init phase, both built in
+ // web extensions freshly installed (via addEnginesFromExtension) or
+ // user installed extensions being reenabled calling this directly.
+ if (!this.isInitialized && !extension.isAppProvided && !initEngine) {
+ await this.init();
+ }
+
+ let shouldSetAsDefault = false;
+ let changeReason = Ci.nsISearchService.CHANGE_REASON_UNKNOWN;
+
+ for (let engine of this._engines.values()) {
+ if (
+ !engine.extensionID &&
+ engine._loadPath.startsWith(`jar:[profile]/extensions/${extension.id}`)
+ ) {
+ // This is a legacy extension engine that needs to be migrated to WebExtensions.
+ lazy.logConsole.debug("Migrating existing engine");
+ shouldSetAsDefault = shouldSetAsDefault || this.defaultEngine == engine;
+ await this.removeEngine(engine);
+ }
+ }
+
+ let newEngine = new lazy.AddonSearchEngine({
+ isAppProvided: extension.isAppProvided,
+ details: {
+ extensionID: extension.id,
+ locale,
+ },
+ });
+ await newEngine.init({
+ settings,
+ extension,
+ locale,
+ });
+
+ // If this extension is starting up, check to see if it previously overrode
+ // an application provided engine that has now been removed from the user's
+ // set-up. If the application provided engine has been removed and was
+ // default, then we should set this engine back to default and copy
+ // the settings across.
+ if (extension.startupReason == "APP_STARTUP") {
+ if (!settings) {
+ settings = await this._settings.get();
+ }
+ // We check the saved settings for the overridden flag, because if the engine
+ // has been removed, we won't have that in _engines.
+ let previouslyOverridden = settings.engines?.find(
+ e => !!e._metaData.overriddenBy
+ );
+ if (previouslyOverridden) {
+ let previousWebExtensionId = previouslyOverridden.id.endsWith("default")
+ ? previouslyOverridden.id.slice(0, -7)
+ : previouslyOverridden.id;
+
+ // Only allow override if we were previously overriding and the
+ // engine is no longer installed, and the new engine still matches the
+ // override allow list.
+ if (
+ previouslyOverridden._metaData.overriddenBy == extension.id &&
+ !this._engines.get(previouslyOverridden.id) &&
+ (await lazy.defaultOverrideAllowlist.canEngineOverride(
+ newEngine,
+ previousWebExtensionId
+ ))
+ ) {
+ shouldSetAsDefault = true;
+ // We assume that the app provided engine was removed due to a
+ // configuration change, and therefore we have re-added the add-on
+ // search engine. It is possible that it was actually due to a
+ // locale/region change, but that is harder to detect here.
+ changeReason = Ci.nsISearchService.CHANGE_REASON_CONFIG;
+ newEngine.copyUserSettingsFrom(previouslyOverridden);
+ }
+ }
+ }
+
+ this.#addEngineToStore(newEngine);
+ if (shouldSetAsDefault) {
+ this.#setEngineDefault(false, newEngine, changeReason);
+ }
+ return newEngine;
+ }
+
+ /**
+ * Called when we see an upgrade to an existing search extension.
+ *
+ * @param {object} extension
+ * An Extension object containing data about the extension.
+ */
+ async #upgradeExtensionEngine(extension) {
+ let { engines } = await this._fetchEngineSelectorEngines();
+ let extensionEngines = await this.getEnginesByExtensionID(extension.id);
+
+ for (let engine of extensionEngines) {
+ let isDefault = engine == this.defaultEngine;
+ let isDefaultPrivate = engine == this.defaultPrivateEngine;
+
+ let originalName = engine.name;
+ let locale = engine._locale || lazy.SearchUtils.DEFAULT_TAG;
+ let configuration =
+ engines.find(
+ e =>
+ e.webExtension.id == extension.id && e.webExtension.locale == locale
+ ) ?? {};
+
+ await engine.update({
+ configuration,
+ extension,
+ locale,
+ });
+
+ if (engine.name != originalName) {
+ if (isDefault) {
+ this._settings.setVerifiedMetaDataAttribute(
+ "defaultEngineId",
+ engine.id
+ );
+ }
+ if (isDefaultPrivate) {
+ this._settings.setVerifiedMetaDataAttribute(
+ "privateDefaultEngineId",
+ engine.id
+ );
+ }
+ this._cachedSortedEngines = null;
+ }
+ }
+ return extensionEngines;
+ }
+
+ async #installExtensionEngine(
+ extension,
+ locales,
+ settings,
+ initEngine = false
+ ) {
+ lazy.logConsole.debug("installExtensionEngine:", extension.id);
+
+ let installLocale = async locale => {
+ return this._createAndAddEngine({
+ extension,
+ locale,
+ settings,
+ initEngine,
+ });
+ };
+
+ let engines = [];
+ for (let locale of locales) {
+ lazy.logConsole.debug(
+ "addEnginesFromExtension: installing:",
+ extension.id,
+ ":",
+ locale
+ );
+ engines.push(await installLocale(locale));
+ }
+ return engines;
+ }
+
+ #internalRemoveEngine(engine) {
+ // Remove the engine from _sortedEngines
+ if (this._cachedSortedEngines) {
+ var index = this._cachedSortedEngines.indexOf(engine);
+ if (index == -1) {
+ throw Components.Exception(
+ "Can't find engine to remove in _sortedEngines!",
+ Cr.NS_ERROR_FAILURE
+ );
+ }
+ this._cachedSortedEngines.splice(index, 1);
+ }
+
+ // Remove the engine from the internal store
+ this._engines.delete(engine.id);
+ }
+
+ /**
+ * Helper function to find a new default engine and set it. This could
+ * be used if there is not default set yet, or if the current default is
+ * being removed.
+ *
+ * This function will not consider engines that have a `pendingRemoval`
+ * property set to true.
+ *
+ * The new default will be chosen from (in order):
+ *
+ * - Existing default from configuration, if it is not hidden.
+ * - The first non-hidden engine that is a general search engine.
+ * - If all other engines are hidden, unhide the default from the configuration.
+ * - If the default from the configuration is the one being removed, unhide
+ * the first general search engine, or first visible engine.
+ *
+ * @param {boolean} privateMode
+ * If true, returns the default engine for private browsing mode, otherwise
+ * the default engine for the normal mode. Note, this function does not
+ * check the "separatePrivateDefault" preference - that is up to the caller.
+ * @returns {nsISearchEngine|null}
+ * The appropriate search engine, or null if one could not be determined.
+ */
+ #findAndSetNewDefaultEngine({ privateMode }) {
+ // First to the app default engine...
+ let newDefault = privateMode
+ ? this.appPrivateDefaultEngine
+ : this.appDefaultEngine;
+
+ if (!newDefault || newDefault.hidden || newDefault.pendingRemoval) {
+ let sortedEngines = this.#sortedVisibleEngines;
+ let generalSearchEngines = sortedEngines.filter(
+ e => e.isGeneralPurposeEngine
+ );
+
+ // then to the first visible general search engine that isn't excluded...
+ let firstVisible = generalSearchEngines.find(e => !e.pendingRemoval);
+ if (firstVisible) {
+ newDefault = firstVisible;
+ } else if (newDefault) {
+ // then to the app default if it is not the one that is excluded...
+ if (!newDefault.pendingRemoval) {
+ newDefault.hidden = false;
+ } else {
+ newDefault = null;
+ }
+ }
+
+ // and finally as a last resort we unhide the first engine
+ // even if the name is the same as the excluded one (should never happen).
+ if (!newDefault) {
+ if (!firstVisible) {
+ sortedEngines = this.#sortedEngines;
+ firstVisible = sortedEngines.find(e => e.isGeneralPurposeEngine);
+ if (!firstVisible) {
+ firstVisible = sortedEngines[0];
+ }
+ }
+ if (firstVisible) {
+ firstVisible.hidden = false;
+ newDefault = firstVisible;
+ }
+ }
+ }
+ // We tried out best but something went very wrong.
+ if (!newDefault) {
+ lazy.logConsole.error("Could not find a replacement default engine.");
+ return null;
+ }
+
+ // If the current engine wasn't set or was hidden, we used a fallback
+ // to pick a new current engine. As soon as we return it, this new
+ // current engine will become user-visible, so we should persist it.
+ // by calling the setter.
+ this.#setEngineDefault(privateMode, newDefault);
+
+ return privateMode ? this.#currentPrivateEngine : this.#currentEngine;
+ }
+
+ /**
+ * Helper function to set the current default engine.
+ *
+ * @param {boolean} privateMode
+ * If true, sets the default engine for private browsing mode, otherwise
+ * sets the default engine for the normal mode. Note, this function does not
+ * check the "separatePrivateDefault" preference - that is up to the caller.
+ * @param {nsISearchEngine} newEngine
+ * The search engine to select
+ * @param {SearchUtils.REASON_CHANGE_MAP} changeSource
+ * The source of the change of engine.
+ */
+ #setEngineDefault(privateMode, newEngine, changeSource) {
+ // Sometimes we get wrapped nsISearchEngine objects (external XPCOM callers),
+ // and sometimes we get raw Engine JS objects (callers in this file), so
+ // handle both.
+ if (
+ !(newEngine instanceof Ci.nsISearchEngine) &&
+ !(newEngine instanceof lazy.SearchEngine)
+ ) {
+ throw Components.Exception(
+ "Invalid argument passed to defaultEngine setter",
+ Cr.NS_ERROR_INVALID_ARG
+ );
+ }
+
+ const newCurrentEngine = this._engines.get(newEngine.id);
+ if (!newCurrentEngine) {
+ throw Components.Exception(
+ "Can't find engine in store!",
+ Cr.NS_ERROR_UNEXPECTED
+ );
+ }
+
+ if (!newCurrentEngine.isAppProvided) {
+ // If a non default engine is being set as the current engine, ensure
+ // its loadPath has a verification hash.
+ if (!newCurrentEngine._loadPath) {
+ newCurrentEngine._loadPath = "[other]unknown";
+ }
+ let loadPathHash = lazy.SearchUtils.getVerificationHash(
+ newCurrentEngine._loadPath
+ );
+ let currentHash = newCurrentEngine.getAttr("loadPathHash");
+ if (!currentHash || currentHash != loadPathHash) {
+ newCurrentEngine.setAttr("loadPathHash", loadPathHash);
+ lazy.SearchUtils.notifyAction(
+ newCurrentEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.CHANGED
+ );
+ }
+ }
+
+ let currentEngine = privateMode
+ ? this.#currentPrivateEngine
+ : this.#currentEngine;
+
+ if (newCurrentEngine == currentEngine) {
+ return;
+ }
+
+ // Ensure that we reset an engine override if it was previously overridden.
+ currentEngine?.removeExtensionOverride();
+
+ if (privateMode) {
+ this.#currentPrivateEngine = newCurrentEngine;
+ } else {
+ this.#currentEngine = newCurrentEngine;
+ }
+
+ // If we change the default engine in the future, that change should impact
+ // users who have switched away from and then back to the build's
+ // "app default" engine. So clear the user pref when the currentEngine is
+ // set to the build's app default engine, so that the currentEngine getter
+ // falls back to whatever the default is.
+ // However, we do not do this whilst we are running an experiment - an
+ // experiment must preseve the user's choice of default engine during it's
+ // runtime and when it ends. Once the experiment ends, we will reset the
+ // attribute elsewhere.
+ let newId = newCurrentEngine.id;
+ const appDefaultEngine = privateMode
+ ? this.appPrivateDefaultEngine
+ : this.appDefaultEngine;
+ if (
+ newCurrentEngine == appDefaultEngine &&
+ !lazy.NimbusFeatures.searchConfiguration.getVariable("experiment")
+ ) {
+ newId = "";
+ }
+
+ this._settings.setVerifiedMetaDataAttribute(
+ privateMode ? "privateDefaultEngineId" : "defaultEngineId",
+ newId
+ );
+
+ // Only do this if we're initialized though - this function can get called
+ // during initalization.
+ if (this.isInitialized) {
+ this.#recordDefaultChangedEvent(
+ privateMode,
+ currentEngine,
+ newCurrentEngine,
+ changeSource
+ );
+ this.#recordTelemetryData();
+ }
+
+ lazy.SearchUtils.notifyAction(
+ newCurrentEngine,
+ lazy.SearchUtils.MODIFIED_TYPE[
+ privateMode ? "DEFAULT_PRIVATE" : "DEFAULT"
+ ]
+ );
+ // If we've not got a separate private active, notify update of the
+ // private so that the UI updates correctly.
+ if (!privateMode && !this.#separatePrivateDefault) {
+ lazy.SearchUtils.notifyAction(
+ newCurrentEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.DEFAULT_PRIVATE
+ );
+ }
+ }
+
+ #onSeparateDefaultPrefChanged(prefName, previousValue, currentValue) {
+ // Clear out the sorted engines settings, so that we re-sort it if necessary.
+ this._cachedSortedEngines = null;
+ // We should notify if the normal default, and the currently saved private
+ // default are different. Otherwise, save the energy.
+ if (this.defaultEngine != this._getEngineDefault(true)) {
+ lazy.SearchUtils.notifyAction(
+ // Always notify with the new private engine, the function checks
+ // the preference value for us.
+ this.defaultPrivateEngine,
+ lazy.SearchUtils.MODIFIED_TYPE.DEFAULT_PRIVATE
+ );
+ }
+ // Always notify about the change of status of private default if the user
+ // toggled the UI.
+ if (
+ prefName ==
+ lazy.SearchUtils.BROWSER_SEARCH_PREF + "separatePrivateDefault"
+ ) {
+ if (!previousValue && currentValue) {
+ this.#recordDefaultChangedEvent(
+ true,
+ null,
+ this._getEngineDefault(true),
+ Ci.nsISearchService.CHANGE_REASON_USER_PRIVATE_SPLIT
+ );
+ } else {
+ this.#recordDefaultChangedEvent(
+ true,
+ this._getEngineDefault(true),
+ null,
+ Ci.nsISearchService.CHANGE_REASON_USER_PRIVATE_SPLIT
+ );
+ }
+ }
+ // Update the telemetry data.
+ this.#recordTelemetryData();
+ }
+
+ #getEngineInfo(engine) {
+ if (!engine) {
+ // The defaultEngine getter will throw if there's no engine at all,
+ // which shouldn't happen unless an add-on or a test deleted all of them.
+ // Our preferences UI doesn't let users do that.
+ console.error("getDefaultEngineInfo: No default engine");
+ return ["NONE", { name: "NONE" }];
+ }
+
+ const engineData = {
+ loadPath: engine._loadPath,
+ name: engine.name ? engine.name : "",
+ };
+
+ if (engine.isAppProvided) {
+ engineData.origin = "default";
+ } else {
+ let currentHash = engine.getAttr("loadPathHash");
+ if (!currentHash) {
+ engineData.origin = "unverified";
+ } else {
+ let loadPathHash = lazy.SearchUtils.getVerificationHash(
+ engine._loadPath
+ );
+ engineData.origin =
+ currentHash == loadPathHash ? "verified" : "invalid";
+ }
+ }
+
+ // For privacy, we only collect the submission URL for default engines...
+ let sendSubmissionURL = engine.isAppProvided;
+
+ if (!sendSubmissionURL) {
+ // ... or engines that are the same domain as a default engine.
+ let engineHost = engine.searchUrlDomain;
+ for (let innerEngine of this._engines.values()) {
+ if (!innerEngine.isAppProvided) {
+ continue;
+ }
+
+ if (innerEngine.searchUrlDomain == engineHost) {
+ sendSubmissionURL = true;
+ break;
+ }
+ }
+
+ if (!sendSubmissionURL) {
+ // ... or well known search domains.
+ //
+ // Starts with: www.google., search.aol., yandex.
+ // or
+ // Ends with: search.yahoo.com, .ask.com, .bing.com, .startpage.com, baidu.com, duckduckgo.com
+ const urlTest =
+ /^(?:www\.google\.|search\.aol\.|yandex\.)|(?:search\.yahoo|\.ask|\.bing|\.startpage|\.baidu|duckduckgo)\.com$/;
+ sendSubmissionURL = urlTest.test(engineHost);
+ }
+ }
+
+ if (sendSubmissionURL) {
+ let uri = engine.searchURLWithNoTerms;
+ uri = uri
+ .mutate()
+ .setUserPass("") // Avoid reporting a username or password.
+ .finalize();
+ engineData.submissionURL = uri.spec;
+ }
+
+ return [engine.telemetryId, engineData];
+ }
+
+ /**
+ * Records an event for where the default engine is changed. This is
+ * recorded to both Glean and Telemetry.
+ *
+ * The Glean GIFFT functionality is not used here because we use longer
+ * names in the extra arguments to the event.
+ *
+ * @param {boolean} isPrivate
+ * True if this is a event about a private engine.
+ * @param {SearchEngine} [previousEngine]
+ * The previously default search engine.
+ * @param {SearchEngine} [newEngine]
+ * The new default search engine.
+ * @param {string} changeSource
+ * The source of the change of default.
+ */
+ #recordDefaultChangedEvent(
+ isPrivate,
+ previousEngine,
+ newEngine,
+ changeSource = Ci.nsISearchService.CHANGE_REASON_UNKNOWN
+ ) {
+ changeSource = REASON_CHANGE_MAP.get(changeSource) ?? "unknown";
+ Services.telemetry.setEventRecordingEnabled("search", true);
+ let telemetryId;
+ let engineInfo;
+ // If we are toggling the separate private browsing settings, we might not
+ // have an engine to record.
+ if (newEngine) {
+ [telemetryId, engineInfo] = this.#getEngineInfo(newEngine);
+ } else {
+ telemetryId = "";
+ engineInfo = {
+ name: "",
+ loadPath: "",
+ submissionURL: "",
+ };
+ }
+
+ let submissionURL = engineInfo.submissionURL ?? "";
+ Services.telemetry.recordEvent(
+ "search",
+ "engine",
+ isPrivate ? "change_private" : "change_default",
+ changeSource,
+ {
+ // In docshell tests, the previous engine does not exist, so we allow
+ // for the previousEngine to be undefined.
+ prev_id: previousEngine?.telemetryId ?? "",
+ new_id: telemetryId,
+ new_name: engineInfo.name,
+ new_load_path: engineInfo.loadPath,
+ // Telemetry has a limit of 80 characters.
+ new_sub_url: submissionURL.slice(0, 80),
+ }
+ );
+
+ let extraArgs = {
+ // In docshell tests, the previous engine does not exist, so we allow
+ // for the previousEngine to be undefined.
+ previous_engine_id: previousEngine?.telemetryId ?? "",
+ new_engine_id: telemetryId,
+ new_display_name: engineInfo.name,
+ new_load_path: engineInfo.loadPath,
+ // Glean has a limit of 100 characters.
+ new_submission_url: submissionURL.slice(0, 100),
+ change_source: changeSource,
+ };
+ if (isPrivate) {
+ Glean.searchEnginePrivate.changed.record(extraArgs);
+ } else {
+ Glean.searchEngineDefault.changed.record(extraArgs);
+ }
+ }
+
+ /**
+ * Records the user's current default engine (normal and private) data to
+ * telemetry.
+ */
+ #recordTelemetryData() {
+ let info = this.getDefaultEngineInfo();
+
+ Glean.searchEngineDefault.engineId.set(info.defaultSearchEngine);
+ Glean.searchEngineDefault.displayName.set(
+ info.defaultSearchEngineData.name
+ );
+ Glean.searchEngineDefault.loadPath.set(
+ info.defaultSearchEngineData.loadPath
+ );
+ Glean.searchEngineDefault.submissionUrl.set(
+ info.defaultSearchEngineData.submissionURL ?? "blank:"
+ );
+ Glean.searchEngineDefault.verified.set(info.defaultSearchEngineData.origin);
+
+ Glean.searchEnginePrivate.engineId.set(
+ info.defaultPrivateSearchEngine ?? ""
+ );
+
+ if (info.defaultPrivateSearchEngineData) {
+ Glean.searchEnginePrivate.displayName.set(
+ info.defaultPrivateSearchEngineData.name
+ );
+ Glean.searchEnginePrivate.loadPath.set(
+ info.defaultPrivateSearchEngineData.loadPath
+ );
+ Glean.searchEnginePrivate.submissionUrl.set(
+ info.defaultPrivateSearchEngineData.submissionURL ?? "blank:"
+ );
+ Glean.searchEnginePrivate.verified.set(
+ info.defaultPrivateSearchEngineData.origin
+ );
+ } else {
+ Glean.searchEnginePrivate.displayName.set("");
+ Glean.searchEnginePrivate.loadPath.set("");
+ Glean.searchEnginePrivate.submissionUrl.set("blank:");
+ Glean.searchEnginePrivate.verified.set("");
+ }
+ }
+
+ /**
+ * This function is called at the beginning of search service init.
+ * If the error type set in a test environment matches errorType
+ * passed to this function, we throw an error.
+ *
+ * @param {string} errorType
+ * The error that can occur during search service init.
+ *
+ */
+ #maybeThrowErrorInTest(errorType) {
+ if (
+ Services.env.exists("XPCSHELL_TEST_PROFILE_DIR") &&
+ this.errorToThrowInTest === errorType
+ ) {
+ throw new Error(
+ `Fake ${errorType} error during search service initialization.`
+ );
+ }
+ }
+
+ #buildParseSubmissionMap() {
+ this.#parseSubmissionMap = new Map();
+
+ // Used only while building the map, indicates which entries do not refer to
+ // the main domain of the engine but to an alternate domain, for example
+ // "www.google.fr" for the "www.google.com" search engine.
+ let keysOfAlternates = new Set();
+
+ for (let engine of this.#sortedEngines) {
+ if (engine.hidden) {
+ continue;
+ }
+
+ let urlParsingInfo = engine.getURLParsingInfo();
+ if (!urlParsingInfo) {
+ continue;
+ }
+
+ // Store the same object on each matching map key, as an optimization.
+ let mapValueForEngine = {
+ engine,
+ termsParameterName: urlParsingInfo.termsParameterName,
+ };
+
+ let processDomain = (domain, isAlternate) => {
+ let key = domain + urlParsingInfo.path;
+
+ // Apply the logic for which main domains take priority over alternate
+ // domains, even if they are found later in the ordered engine list.
+ let existingEntry = this.#parseSubmissionMap.get(key);
+ if (!existingEntry) {
+ if (isAlternate) {
+ keysOfAlternates.add(key);
+ }
+ } else if (!isAlternate && keysOfAlternates.has(key)) {
+ keysOfAlternates.delete(key);
+ } else {
+ return;
+ }
+
+ this.#parseSubmissionMap.set(key, mapValueForEngine);
+ };
+
+ processDomain(urlParsingInfo.mainDomain, false);
+ lazy.SearchStaticData.getAlternateDomains(
+ urlParsingInfo.mainDomain
+ ).forEach(d => processDomain(d, true));
+ }
+ }
+
+ #nimbusSearchUpdatedFun = null;
+
+ async #nimbusSearchUpdated() {
+ this.#checkNimbusPrefs();
+ Services.search.wrappedJSObject._maybeReloadEngines(
+ Ci.nsISearchService.CHANGE_REASON_EXPERIMENT
+ );
+ }
+
+ /**
+ * Check the prefs are correctly updated for users enrolled in a Nimbus experiment.
+ *
+ * @param {boolean} isStartup
+ * Whether this function was called as part of the startup flow.
+ */
+ #checkNimbusPrefs(isStartup = false) {
+ // If we are in an experiment we may need to check the status on startup, otherwise
+ // ignore the call to check on startup so we do not reset users prefs when they are
+ // not an experiment.
+ if (
+ isStartup &&
+ !lazy.NimbusFeatures.searchConfiguration.getVariable("experiment")
+ ) {
+ return;
+ }
+ let nimbusPrivateDefaultUIEnabled =
+ lazy.NimbusFeatures.searchConfiguration.getVariable(
+ "seperatePrivateDefaultUIEnabled"
+ );
+ let nimbusPrivateDefaultUrlbarResultEnabled =
+ lazy.NimbusFeatures.searchConfiguration.getVariable(
+ "seperatePrivateDefaultUrlbarResultEnabled"
+ );
+
+ let previousPrivateDefault = this.defaultPrivateEngine;
+ let uiWasEnabled = this._separatePrivateDefaultEnabledPrefValue;
+ if (
+ this._separatePrivateDefaultEnabledPrefValue !=
+ nimbusPrivateDefaultUIEnabled
+ ) {
+ Services.prefs.setBoolPref(
+ `${lazy.SearchUtils.BROWSER_SEARCH_PREF}separatePrivateDefault.ui.enabled`,
+ nimbusPrivateDefaultUIEnabled
+ );
+ let newPrivateDefault = this.defaultPrivateEngine;
+ if (previousPrivateDefault != newPrivateDefault) {
+ if (!uiWasEnabled) {
+ this.#recordDefaultChangedEvent(
+ true,
+ null,
+ newPrivateDefault,
+ Ci.nsISearchService.CHANGE_REASON_EXPERIMENT
+ );
+ } else {
+ this.#recordDefaultChangedEvent(
+ true,
+ previousPrivateDefault,
+ null,
+ Ci.nsISearchService.CHANGE_REASON_EXPERIMENT
+ );
+ }
+ }
+ }
+ if (
+ this.separatePrivateDefaultUrlbarResultEnabled !=
+ nimbusPrivateDefaultUrlbarResultEnabled
+ ) {
+ Services.prefs.setBoolPref(
+ `${lazy.SearchUtils.BROWSER_SEARCH_PREF}separatePrivateDefault.urlbarResult.enabled`,
+ nimbusPrivateDefaultUrlbarResultEnabled
+ );
+ }
+ }
+
+ #addObservers() {
+ if (this.#observersAdded) {
+ // There might be a race between synchronous and asynchronous
+ // initialization for which we try to register the observers twice.
+ return;
+ }
+ this.#observersAdded = true;
+
+ this.#nimbusSearchUpdatedFun = this.#nimbusSearchUpdated.bind(this);
+ lazy.NimbusFeatures.searchConfiguration.onUpdate(
+ this.#nimbusSearchUpdatedFun
+ );
+
+ Services.obs.addObserver(this, lazy.SearchUtils.TOPIC_ENGINE_MODIFIED);
+ Services.obs.addObserver(this, QUIT_APPLICATION_TOPIC);
+ Services.obs.addObserver(this, TOPIC_LOCALES_CHANGE);
+
+ this._settings.addObservers();
+
+ // The current stage of shutdown. Used to help analyze crash
+ // signatures in case of shutdown timeout.
+ let shutdownState = {
+ step: "Not started",
+ latestError: {
+ message: undefined,
+ stack: undefined,
+ },
+ };
+ IOUtils.profileBeforeChange.addBlocker(
+ "Search service: shutting down",
+ () =>
+ (async () => {
+ // If we are in initialization, then don't attempt to save the settings.
+ // It is likely that shutdown will have caused the add-on manager to
+ // stop, which can cause initialization to fail.
+ // Hence at that stage, we could have broken settings which we don't
+ // want to write.
+ // The good news is, that if we don't write the settings here, we'll
+ // detect the out-of-date settings on next state, and automatically
+ // rebuild it.
+ if (!this.isInitialized) {
+ lazy.logConsole.warn(
+ "not saving settings on shutdown due to initializing."
+ );
+ return;
+ }
+
+ try {
+ await this._settings.shutdown(shutdownState);
+ } catch (ex) {
+ // Ensure that error is reported and that it causes tests
+ // to fail, otherwise ignore it.
+ Promise.reject(ex);
+ }
+ })(),
+
+ () => shutdownState
+ );
+ }
+
+ // This is prefixed with _ rather than # because it is
+ // called in a test.
+ _removeObservers() {
+ if (this.ignoreListListener) {
+ lazy.IgnoreLists.unsubscribe(this.ignoreListListener);
+ delete this.ignoreListListener;
+ }
+ if (this.#queuedIdle) {
+ this.idleService.removeIdleObserver(this, RECONFIG_IDLE_TIME_SEC);
+ this.#queuedIdle = false;
+ }
+
+ this._settings.removeObservers();
+
+ lazy.NimbusFeatures.searchConfiguration.offUpdate(
+ this.#nimbusSearchUpdatedFun
+ );
+
+ Services.obs.removeObserver(this, lazy.SearchUtils.TOPIC_ENGINE_MODIFIED);
+ Services.obs.removeObserver(this, QUIT_APPLICATION_TOPIC);
+ Services.obs.removeObserver(this, TOPIC_LOCALES_CHANGE);
+ Services.obs.removeObserver(this, lazy.Region.REGION_TOPIC);
+ }
+
+ QueryInterface = ChromeUtils.generateQI([
+ "nsISearchService",
+ "nsIObserver",
+ "nsITimerCallback",
+ ]);
+
+ // nsIObserver
+ observe(engine, topic, verb) {
+ switch (topic) {
+ case lazy.SearchUtils.TOPIC_ENGINE_MODIFIED:
+ switch (verb) {
+ case lazy.SearchUtils.MODIFIED_TYPE.ADDED:
+ this.#parseSubmissionMap = null;
+ break;
+ case lazy.SearchUtils.MODIFIED_TYPE.CHANGED:
+ engine = engine.wrappedJSObject;
+ if (
+ engine == this.defaultEngine ||
+ engine == this.defaultPrivateEngine
+ ) {
+ this.#recordDefaultChangedEvent(
+ engine != this.defaultEngine,
+ engine,
+ engine,
+ Ci.nsISearchService.CHANGE_REASON_ENGINE_UPDATE
+ );
+ }
+ this.#parseSubmissionMap = null;
+ break;
+ case lazy.SearchUtils.MODIFIED_TYPE.REMOVED:
+ // Invalidate the map used to parse URLs to search engines.
+ this.#parseSubmissionMap = null;
+ break;
+ }
+ break;
+
+ case "idle": {
+ this.idleService.removeIdleObserver(this, RECONFIG_IDLE_TIME_SEC);
+ this.#queuedIdle = false;
+ lazy.logConsole.debug(
+ "Reloading engines after idle due to configuration change"
+ );
+ this._maybeReloadEngines(
+ Ci.nsISearchService.CHANGE_REASON_CONFIG
+ ).catch(console.error);
+ break;
+ }
+
+ case QUIT_APPLICATION_TOPIC:
+ this._removeObservers();
+ break;
+
+ case TOPIC_LOCALES_CHANGE:
+ // Locale changed. Re-init. We rely on observers, because we can't
+ // return this promise to anyone.
+
+ // At the time of writing, when the user does a "Apply and Restart" for
+ // a new language the preferences code triggers the locales change and
+ // restart straight after, so we delay the check, which means we should
+ // be able to avoid the reload on shutdown, and we'll sort it out
+ // on next startup.
+ // This also helps to avoid issues with the add-on manager shutting
+ // down at the same time (see _reInit for more info).
+ Services.tm.dispatchToMainThread(() => {
+ if (!Services.startup.shuttingDown) {
+ this._maybeReloadEngines(
+ Ci.nsISearchService.CHANGE_REASON_LOCALE
+ ).catch(console.error);
+ }
+ });
+ break;
+ case lazy.Region.REGION_TOPIC:
+ lazy.logConsole.debug("Region updated:", lazy.Region.home);
+ this._maybeReloadEngines(
+ Ci.nsISearchService.CHANGE_REASON_REGION
+ ).catch(console.error);
+ break;
+ }
+ }
+
+ /**
+ * Create an engine object from the search configuration details.
+ *
+ * This method is prefixed with _ rather than # because it is
+ * called in a test.
+ *
+ * @param {object} config
+ * The configuration object that defines the details of the engine
+ * webExtensionId etc.
+ * @param {object} [settings]
+ * The saved settings for the user.
+ * @returns {nsISearchEngine}
+ * Returns the search engine object.
+ */
+ async _makeEngineFromConfig(config, settings) {
+ lazy.logConsole.debug("_makeEngineFromConfig:", config);
+
+ if (!lazy.SearchUtils.newSearchConfigEnabled) {
+ let locale =
+ "locale" in config.webExtension
+ ? config.webExtension.locale
+ : lazy.SearchUtils.DEFAULT_TAG;
+
+ let engine = new lazy.AddonSearchEngine({
+ isAppProvided: true,
+ details: {
+ extensionID: config.webExtension.id,
+ locale,
+ },
+ });
+ await engine.init({
+ settings,
+ locale,
+ config,
+ });
+ return engine;
+ }
+
+ return new lazy.AppProvidedSearchEngine({ config, settings });
+ }
+
+ /**
+ * @param {object} metaData
+ * The metadata object that defines the details of the engine.
+ * @returns {boolean}
+ * Returns true if metaData has different property values than
+ * the cached _metaData.
+ */
+ #didSettingsMetaDataUpdate(metaData) {
+ let metaDataProperties = [
+ "locale",
+ "region",
+ "channel",
+ "experiment",
+ "distroID",
+ ];
+
+ return metaDataProperties.some(p => {
+ return metaData?.[p] !== this._settings.getMetaDataAttribute(p);
+ });
+ }
+
+ /**
+ * Shows an infobar to notify the user their default search engine has been
+ * removed and replaced by a new default search engine.
+ *
+ * This method is prefixed with _ rather than # because it is
+ * called in a test.
+ *
+ * @param {string} prevCurrentEngineName
+ * The name of the previous default engine that will be replaced.
+ * @param {string} newCurrentEngineName
+ * The name of the engine that will be the new default engine.
+ *
+ */
+ _showRemovalOfSearchEngineNotificationBox(
+ prevCurrentEngineName,
+ newCurrentEngineName
+ ) {
+ let win = Services.wm.getMostRecentBrowserWindow();
+ win.BrowserSearch.removalOfSearchEngineNotificationBox(
+ prevCurrentEngineName,
+ newCurrentEngineName
+ );
+ }
+
+ /**
+ * Maybe starts the timer for OpenSearch engine updates. This will be set
+ * only if updates are enabled and there are OpenSearch engines installed
+ * which have updates.
+ */
+ #maybeStartOpenSearchUpdateTimer() {
+ if (
+ this.#openSearchUpdateTimerStarted ||
+ !Services.prefs.getBoolPref(
+ lazy.SearchUtils.BROWSER_SEARCH_PREF + "update",
+ true
+ )
+ ) {
+ return;
+ }
+
+ let engineWithUpdates = [...this._engines.values()].some(
+ engine => engine instanceof lazy.OpenSearchEngine && engine.hasUpdates
+ );
+
+ if (engineWithUpdates) {
+ lazy.logConsole.debug("Engine with updates found, setting update timer");
+ lazy.timerManager.registerTimer(
+ OPENSEARCH_UPDATE_TIMER_TOPIC,
+ this,
+ OPENSEARCH_UPDATE_TIMER_INTERVAL,
+ true
+ );
+ this.#openSearchUpdateTimerStarted = true;
+ }
+ }
+} // end SearchService class
+
+XPCOMUtils.defineLazyServiceGetter(
+ SearchService.prototype,
+ "idleService",
+ "@mozilla.org/widget/useridleservice;1",
+ "nsIUserIdleService"
+);
+
+/**
+ * Handles getting and checking extensions against the allow list.
+ */
+class SearchDefaultOverrideAllowlistHandler {
+ /**
+ * @param {Function} listener
+ * A listener for configuration update changes.
+ */
+ constructor(listener) {
+ this._remoteConfig = lazy.RemoteSettings(
+ lazy.SearchUtils.SETTINGS_ALLOWLIST_KEY
+ );
+ }
+
+ /**
+ * Determines if a search engine extension can override a default one
+ * according to the allow list.
+ *
+ * @param {object} extension
+ * The extension object (from add-on manager) that will override the
+ * app provided search engine.
+ * @param {string} appProvidedExtensionId
+ * The id of the search engine that will be overriden.
+ * @returns {boolean}
+ * Returns true if the search engine extension may override the app provided
+ * instance.
+ */
+ async canOverride(extension, appProvidedExtensionId) {
+ const overrideTable = await this._getAllowlist();
+
+ let entry = overrideTable.find(e => e.thirdPartyId == extension.id);
+ if (!entry) {
+ return false;
+ }
+
+ if (appProvidedExtensionId != entry.overridesId) {
+ return false;
+ }
+
+ let searchProvider =
+ extension.manifest.chrome_settings_overrides.search_provider;
+
+ return entry.urls.some(
+ e =>
+ searchProvider.search_url == e.search_url &&
+ searchProvider.search_form == e.search_form &&
+ searchProvider.search_url_get_params == e.search_url_get_params &&
+ searchProvider.search_url_post_params == e.search_url_post_params
+ );
+ }
+
+ /**
+ * Determines if an existing search engine is allowed to override a default one
+ * according to the allow list.
+ *
+ * @param {SearchEngine} engine
+ * The existing search engine.
+ * @param {string} appProvidedEngineExtensionId
+ * The id of the search engine that will be overriden.
+ * @returns {boolean}
+ * Returns true if the existing search engine is allowed to override the
+ * app provided instance.
+ */
+ async canEngineOverride(engine, appProvidedEngineExtensionId) {
+ const overrideEntries = await this._getAllowlist();
+
+ let entry;
+
+ if (engine instanceof lazy.AddonSearchEngine) {
+ entry = overrideEntries.find(e => e.thirdPartyId == engine._extensionID);
+ } else if (engine instanceof lazy.OpenSearchEngine) {
+ entry = overrideEntries.find(
+ e =>
+ e.thirdPartyId == "opensearch@search.mozilla.org" &&
+ e.engineName == engine.name
+ );
+ }
+ if (!entry) {
+ return false;
+ }
+
+ if (appProvidedEngineExtensionId != entry.overridesId) {
+ return false;
+ }
+
+ return entry.urls.some(urlSet =>
+ engine.checkSearchUrlMatchesManifest(urlSet)
+ );
+ }
+
+ /**
+ * Obtains the configuration from remote settings. This includes
+ * verifying the signature of the record within the database.
+ *
+ * If the signature in the database is invalid, the database will be wiped
+ * and the stored dump will be used, until the settings next update.
+ *
+ * Note that this may cause a network check of the certificate, but that
+ * should generally be quick.
+ *
+ * @returns {Array}
+ * An array of objects in the database, or an empty array if none
+ * could be obtained.
+ */
+ async _getAllowlist() {
+ let result = [];
+ try {
+ result = await this._remoteConfig.get();
+ } catch (ex) {
+ // Don't throw an error just log it, just continue with no data, and hopefully
+ // a sync will fix things later on.
+ console.error(ex);
+ }
+ lazy.logConsole.debug("Allow list is:", result);
+ return result;
+ }
+}