Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 667 insertions, 0 deletions

diff --git a/browser/actors/ContentSearchParent.sys.mjs b/browser/actors/ContentSearchParent.sys.mjs
new file mode 100644
index 0000000000..a9c805bbb8
--- /dev/null
+++ b/browser/actors/ContentSearchParent.sys.mjs
@@ -0,0 +1,667 @@
+/* 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/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  BrowserSearchTelemetry: "resource:///modules/BrowserSearchTelemetry.sys.mjs",
+  FormHistory: "resource://gre/modules/FormHistory.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  SearchSuggestionController:
+    "resource://gre/modules/SearchSuggestionController.sys.mjs",
+  UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs",
+});
+
+const MAX_LOCAL_SUGGESTIONS = 3;
+const MAX_SUGGESTIONS = 6;
+const SEARCH_ENGINE_PLACEHOLDER_ICON =
+  "chrome://browser/skin/search-engine-placeholder.png";
+
+// Set of all ContentSearch actors, used to broadcast messages to all of them.
+let gContentSearchActors = new Set();
+
+/**
+ * Inbound messages have the following types:
+ *
+ *   AddFormHistoryEntry
+ *     Adds an entry to the search form history.
+ *     data: the entry, a string
+ *   GetSuggestions
+ *     Retrieves an array of search suggestions given a search string.
+ *     data: { engineName, searchString }
+ *   GetState
+ *     Retrieves the current search engine state.
+ *     data: null
+ *   GetStrings
+ *     Retrieves localized search UI strings.
+ *     data: null
+ *   ManageEngines
+ *     Opens the search engine management window.
+ *     data: null
+ *   RemoveFormHistoryEntry
+ *     Removes an entry from the search form history.
+ *     data: the entry, a string
+ *   Search
+ *     Performs a search.
+ *     Any GetSuggestions messages in the queue from the same target will be
+ *     cancelled.
+ *     data: { engineName, searchString, healthReportKey, searchPurpose }
+ *   SetCurrentEngine
+ *     Sets the current engine.
+ *     data: the name of the engine
+ *   SpeculativeConnect
+ *     Speculatively connects to an engine.
+ *     data: the name of the engine
+ *
+ * Outbound messages have the following types:
+ *
+ *   CurrentEngine
+ *     Broadcast when the current engine changes.
+ *     data: see _currentEngineObj
+ *   CurrentState
+ *     Broadcast when the current search state changes.
+ *     data: see currentStateObj
+ *   State
+ *     Sent in reply to GetState.
+ *     data: see currentStateObj
+ *   Strings
+ *     Sent in reply to GetStrings
+ *     data: Object containing string names and values for the current locale.
+ *   Suggestions
+ *     Sent in reply to GetSuggestions.
+ *     data: see _onMessageGetSuggestions
+ *   SuggestionsCancelled
+ *     Sent in reply to GetSuggestions when pending GetSuggestions events are
+ *     cancelled.
+ *     data: null
+ */
+
+export let ContentSearch = {
+  initialized: false,
+
+  // Inbound events are queued and processed in FIFO order instead of handling
+  // them immediately, which would result in non-FIFO responses due to the
+  // asynchrononicity added by converting image data URIs to ArrayBuffers.
+  _eventQueue: [],
+  _currentEventPromise: null,
+
+  // This is used to handle search suggestions.  It maps xul:browsers to objects
+  // { controller, previousFormHistoryResult }.  See _onMessageGetSuggestions.
+  _suggestionMap: new WeakMap(),
+
+  // Resolved when we finish shutting down.
+  _destroyedPromise: null,
+
+  // The current controller and browser in _onMessageGetSuggestions.  Allows
+  // fetch cancellation from _cancelSuggestions.
+  _currentSuggestion: null,
+
+  init() {
+    if (!this.initialized) {
+      Services.obs.addObserver(this, "browser-search-engine-modified");
+      Services.obs.addObserver(this, "browser-search-service");
+      Services.obs.addObserver(this, "shutdown-leaks-before-check");
+      Services.prefs.addObserver("browser.search.hiddenOneOffs", this);
+      lazy.UrlbarPrefs.addObserver(this);
+
+      this.initialized = true;
+    }
+  },
+
+  get searchSuggestionUIStrings() {
+    if (this._searchSuggestionUIStrings) {
+      return this._searchSuggestionUIStrings;
+    }
+    this._searchSuggestionUIStrings = {};
+    let searchBundle = Services.strings.createBundle(
+      "chrome://browser/locale/search.properties"
+    );
+    let stringNames = [
+      "searchHeader",
+      "searchForSomethingWith2",
+      "searchWithHeader",
+      "searchSettings",
+    ];
+
+    for (let name of stringNames) {
+      this._searchSuggestionUIStrings[name] = searchBundle.GetStringFromName(
+        name
+      );
+    }
+    return this._searchSuggestionUIStrings;
+  },
+
+  destroy() {
+    if (!this.initialized) {
+      return new Promise();
+    }
+
+    if (this._destroyedPromise) {
+      return this._destroyedPromise;
+    }
+
+    Services.prefs.removeObserver("browser.search.hiddenOneOffs", this);
+    Services.obs.removeObserver(this, "browser-search-engine-modified");
+    Services.obs.removeObserver(this, "browser-search-service");
+    Services.obs.removeObserver(this, "shutdown-leaks-before-check");
+
+    this._eventQueue.length = 0;
+    this._destroyedPromise = Promise.resolve(this._currentEventPromise);
+    return this._destroyedPromise;
+  },
+
+  observe(subj, topic, data) {
+    switch (topic) {
+      case "browser-search-service":
+        if (data != "init-complete") {
+          break;
+        }
+      // fall through
+      case "nsPref:changed":
+      case "browser-search-engine-modified":
+        this._eventQueue.push({
+          type: "Observe",
+          data,
+        });
+        this._processEventQueue();
+        break;
+      case "shutdown-leaks-before-check":
+        subj.wrappedJSObject.client.addBlocker(
+          "ContentSearch: Wait until the service is destroyed",
+          () => this.destroy()
+        );
+        break;
+    }
+  },
+
+  /**
+   * Observes changes in prefs tracked by UrlbarPrefs.
+   * @param {string} pref
+   *   The name of the pref, relative to `browser.urlbar.` if the pref is
+   *   in that branch.
+   */
+  onPrefChanged(pref) {
+    if (lazy.UrlbarPrefs.shouldHandOffToSearchModePrefs.includes(pref)) {
+      this._eventQueue.push({
+        type: "Observe",
+        data: "shouldHandOffToSearchMode",
+      });
+      this._processEventQueue();
+    }
+  },
+
+  removeFormHistoryEntry(browser, entry) {
+    let browserData = this._suggestionDataForBrowser(browser);
+    if (browserData && browserData.previousFormHistoryResult) {
+      let { previousFormHistoryResult } = browserData;
+      for (let i = 0; i < previousFormHistoryResult.matchCount; i++) {
+        if (previousFormHistoryResult.getValueAt(i) === entry) {
+          previousFormHistoryResult.removeValueAt(i);
+          break;
+        }
+      }
+    }
+  },
+
+  performSearch(actor, browser, data) {
+    this._ensureDataHasProperties(data, [
+      "engineName",
+      "searchString",
+      "healthReportKey",
+      "searchPurpose",
+    ]);
+    let engine = Services.search.getEngineByName(data.engineName);
+    let submission = engine.getSubmission(
+      data.searchString,
+      "",
+      data.searchPurpose
+    );
+    let win = browser.ownerGlobal;
+    if (!win) {
+      // The browser may have been closed between the time its content sent the
+      // message and the time we handle it.
+      return;
+    }
+    let where = win.whereToOpenLink(data.originalEvent);
+
+    // There is a chance that by the time we receive the search message, the user
+    // has switched away from the tab that triggered the search. If, based on the
+    // event, we need to load the search in the same tab that triggered it (i.e.
+    // where === "current"), openUILinkIn will not work because that tab is no
+    // longer the current one. For this case we manually load the URI.
+    if (where === "current") {
+      // Since we're going to load the search in the same browser, blur the search
+      // UI to prevent further interaction before we start loading.
+      this._reply(actor, "Blur");
+      browser.loadURI(submission.uri.spec, {
+        postData: submission.postData,
+        triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal(
+          {
+            userContextId: win.gBrowser.selectedBrowser.getAttribute(
+              "userContextId"
+            ),
+          }
+        ),
+      });
+    } else {
+      let params = {
+        postData: submission.postData,
+        inBackground: Services.prefs.getBoolPref(
+          "browser.tabs.loadInBackground"
+        ),
+      };
+      win.openTrustedLinkIn(submission.uri.spec, where, params);
+    }
+    lazy.BrowserSearchTelemetry.recordSearch(
+      browser,
+      engine,
+      data.healthReportKey,
+      {
+        selection: data.selection,
+        url: submission.uri,
+      }
+    );
+  },
+
+  async getSuggestions(engineName, searchString, browser) {
+    let engine = Services.search.getEngineByName(engineName);
+    if (!engine) {
+      throw new Error("Unknown engine name: " + engineName);
+    }
+
+    let browserData = this._suggestionDataForBrowser(browser, true);
+    let { controller } = browserData;
+    let ok = lazy.SearchSuggestionController.engineOffersSuggestions(engine);
+    controller.maxLocalResults = ok ? MAX_LOCAL_SUGGESTIONS : MAX_SUGGESTIONS;
+    controller.maxRemoteResults = ok ? MAX_SUGGESTIONS : 0;
+    let priv = lazy.PrivateBrowsingUtils.isBrowserPrivate(browser);
+    // fetch() rejects its promise if there's a pending request, but since we
+    // process our event queue serially, there's never a pending request.
+    this._currentSuggestion = { controller, browser };
+    let suggestions = await controller.fetch(searchString, priv, engine);
+
+    // Simplify results since we do not support rich results in this component.
+    suggestions.local = suggestions.local.map(e => e.value);
+    // We shouldn't show tail suggestions in their full-text form.
+    let nonTailEntries = suggestions.remote.filter(
+      e => !e.matchPrefix && !e.tail
+    );
+    suggestions.remote = nonTailEntries.map(e => e.value);
+
+    this._currentSuggestion = null;
+
+    // suggestions will be null if the request was cancelled
+    let result = {};
+    if (!suggestions) {
+      return result;
+    }
+
+    // Keep the form history result so RemoveFormHistoryEntry can remove entries
+    // from it.  Keeping only one result isn't foolproof because the client may
+    // try to remove an entry from one set of suggestions after it has requested
+    // more but before it's received them.  In that case, the entry may not
+    // appear in the new suggestions.  But that should happen rarely.
+    browserData.previousFormHistoryResult = suggestions.formHistoryResult;
+    result = {
+      engineName,
+      term: suggestions.term,
+      local: suggestions.local,
+      remote: suggestions.remote,
+    };
+    return result;
+  },
+
+  async addFormHistoryEntry(browser, entry = null) {
+    let isPrivate = false;
+    try {
+      // isBrowserPrivate assumes that the passed-in browser has all the normal
+      // properties, which won't be true if the browser has been destroyed.
+      // That may be the case here due to the asynchronous nature of messaging.
+      isPrivate = lazy.PrivateBrowsingUtils.isBrowserPrivate(browser);
+    } catch (err) {
+      return false;
+    }
+    if (
+      isPrivate ||
+      !entry ||
+      entry.value.length >
+        lazy.SearchSuggestionController.SEARCH_HISTORY_MAX_VALUE_LENGTH
+    ) {
+      return false;
+    }
+    let browserData = this._suggestionDataForBrowser(browser, true);
+    lazy.FormHistory.update({
+      op: "bump",
+      fieldname: browserData.controller.formHistoryParam,
+      value: entry.value,
+      source: entry.engineName,
+    }).catch(err => console.error("Error adding form history entry: ", err));
+    return true;
+  },
+
+  async currentStateObj(window) {
+    let state = {
+      engines: [],
+      currentEngine: await this._currentEngineObj(false),
+      currentPrivateEngine: await this._currentEngineObj(true),
+    };
+
+    let pref = Services.prefs.getStringPref("browser.search.hiddenOneOffs");
+    let hiddenList = pref ? pref.split(",") : [];
+    for (let engine of await Services.search.getVisibleEngines()) {
+      state.engines.push({
+        name: engine.name,
+        iconData: await this._getEngineIconURL(engine),
+        hidden: hiddenList.includes(engine.name),
+        isAppProvided: engine.isAppProvided,
+      });
+    }
+
+    if (window) {
+      state.isInPrivateBrowsingMode = lazy.PrivateBrowsingUtils.isContentWindowPrivate(
+        window
+      );
+      state.isAboutPrivateBrowsing =
+        window.gBrowser.currentURI.spec == "about:privatebrowsing";
+    }
+
+    return state;
+  },
+
+  _processEventQueue() {
+    if (this._currentEventPromise || !this._eventQueue.length) {
+      return;
+    }
+
+    let event = this._eventQueue.shift();
+
+    this._currentEventPromise = (async () => {
+      try {
+        await this["_on" + event.type](event);
+      } catch (err) {
+        console.error(err);
+      } finally {
+        this._currentEventPromise = null;
+
+        this._processEventQueue();
+      }
+    })();
+  },
+
+  _cancelSuggestions({ actor, browser }) {
+    let cancelled = false;
+    // cancel active suggestion request
+    if (
+      this._currentSuggestion &&
+      this._currentSuggestion.browser === browser
+    ) {
+      this._currentSuggestion.controller.stop();
+      cancelled = true;
+    }
+    // cancel queued suggestion requests
+    for (let i = 0; i < this._eventQueue.length; i++) {
+      let m = this._eventQueue[i];
+      if (actor === m.actor && m.name === "GetSuggestions") {
+        this._eventQueue.splice(i, 1);
+        cancelled = true;
+        i--;
+      }
+    }
+    if (cancelled) {
+      this._reply(actor, "SuggestionsCancelled");
+    }
+  },
+
+  async _onMessage(eventItem) {
+    let methodName = "_onMessage" + eventItem.name;
+    if (methodName in this) {
+      await this._initService();
+      await this[methodName](eventItem);
+      eventItem.browser.removeEventListener("SwapDocShells", eventItem, true);
+    }
+  },
+
+  _onMessageGetState({ actor, browser }) {
+    return this.currentStateObj(browser.ownerGlobal).then(state => {
+      this._reply(actor, "State", state);
+    });
+  },
+
+  _onMessageGetEngine({ actor, browser }) {
+    return this.currentStateObj(browser.ownerGlobal).then(state => {
+      this._reply(actor, "Engine", {
+        isPrivateEngine: state.isInPrivateBrowsingMode,
+        isAboutPrivateBrowsing: state.isAboutPrivateBrowsing,
+        engine: state.isInPrivateBrowsingMode
+          ? state.currentPrivateEngine
+          : state.currentEngine,
+      });
+    });
+  },
+
+  _onMessageGetHandoffSearchModePrefs({ actor }) {
+    this._reply(
+      actor,
+      "HandoffSearchModePrefs",
+      lazy.UrlbarPrefs.get("shouldHandOffToSearchMode")
+    );
+  },
+
+  _onMessageGetStrings({ actor }) {
+    this._reply(actor, "Strings", this.searchSuggestionUIStrings);
+  },
+
+  _onMessageSearch({ actor, browser, data }) {
+    this.performSearch(actor, browser, data);
+  },
+
+  _onMessageSetCurrentEngine({ data }) {
+    Services.search.setDefault(
+      Services.search.getEngineByName(data),
+      Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR
+    );
+  },
+
+  _onMessageManageEngines({ browser }) {
+    browser.ownerGlobal.openPreferences("paneSearch");
+  },
+
+  async _onMessageGetSuggestions({ actor, browser, data }) {
+    this._ensureDataHasProperties(data, ["engineName", "searchString"]);
+    let { engineName, searchString } = data;
+    let suggestions = await this.getSuggestions(
+      engineName,
+      searchString,
+      browser
+    );
+
+    this._reply(actor, "Suggestions", {
+      engineName: data.engineName,
+      searchString: suggestions.term,
+      formHistory: suggestions.local,
+      remote: suggestions.remote,
+    });
+  },
+
+  async _onMessageAddFormHistoryEntry({ browser, data: entry }) {
+    await this.addFormHistoryEntry(browser, entry);
+  },
+
+  _onMessageRemoveFormHistoryEntry({ browser, data: entry }) {
+    this.removeFormHistoryEntry(browser, entry);
+  },
+
+  _onMessageSpeculativeConnect({ browser, data: engineName }) {
+    let engine = Services.search.getEngineByName(engineName);
+    if (!engine) {
+      throw new Error("Unknown engine name: " + engineName);
+    }
+    if (browser.contentWindow) {
+      engine.speculativeConnect({
+        window: browser.contentWindow,
+        originAttributes: browser.contentPrincipal.originAttributes,
+      });
+    }
+  },
+
+  async _onObserve(eventItem) {
+    let engine;
+    switch (eventItem.data) {
+      case "engine-default":
+        engine = await this._currentEngineObj(false);
+        this._broadcast("CurrentEngine", engine);
+        break;
+      case "engine-default-private":
+        engine = await this._currentEngineObj(true);
+        this._broadcast("CurrentPrivateEngine", engine);
+        break;
+      case "shouldHandOffToSearchMode":
+        this._broadcast(
+          "HandoffSearchModePrefs",
+          lazy.UrlbarPrefs.get("shouldHandOffToSearchMode")
+        );
+        break;
+      default:
+        let state = await this.currentStateObj();
+        this._broadcast("CurrentState", state);
+        break;
+    }
+  },
+
+  _suggestionDataForBrowser(browser, create = false) {
+    let data = this._suggestionMap.get(browser);
+    if (!data && create) {
+      // Since one SearchSuggestionController instance is meant to be used per
+      // autocomplete widget, this means that we assume each xul:browser has at
+      // most one such widget.
+      data = {
+        controller: new lazy.SearchSuggestionController(),
+      };
+      this._suggestionMap.set(browser, data);
+    }
+    return data;
+  },
+
+  _reply(actor, type, data) {
+    actor.sendAsyncMessage(type, data);
+  },
+
+  _broadcast(type, data) {
+    for (let actor of gContentSearchActors) {
+      actor.sendAsyncMessage(type, data);
+    }
+  },
+
+  async _currentEngineObj(usePrivate) {
+    let engine =
+      Services.search[usePrivate ? "defaultPrivateEngine" : "defaultEngine"];
+    let obj = {
+      name: engine.name,
+      iconData: await this._getEngineIconURL(engine),
+      isAppProvided: engine.isAppProvided,
+    };
+    return obj;
+  },
+
+  /**
+   * Converts the engine's icon into an appropriate URL for display at
+   */
+  async _getEngineIconURL(engine) {
+    let url = engine.getIconURLBySize(16, 16);
+    if (!url) {
+      return SEARCH_ENGINE_PLACEHOLDER_ICON;
+    }
+
+    // The uri received here can be of two types
+    // 1 - moz-extension://[uuid]/path/to/icon.ico
+    // 2 - data:image/x-icon;base64,VERY-LONG-STRING
+    //
+    // If the URI is not a data: URI, there's no point in converting
+    // it to an arraybuffer (which is used to optimize passing the data
+    // accross processes): we can just pass the original URI, which is cheaper.
+    if (!url.startsWith("data:")) {
+      return url;
+    }
+
+    return new Promise(resolve => {
+      let xhr = new XMLHttpRequest();
+      xhr.open("GET", url, true);
+      xhr.responseType = "arraybuffer";
+      xhr.onload = () => {
+        resolve(xhr.response);
+      };
+      xhr.onerror = xhr.onabort = xhr.ontimeout = () => {
+        resolve(SEARCH_ENGINE_PLACEHOLDER_ICON);
+      };
+      try {
+        // This throws if the URI is erroneously encoded.
+        xhr.send();
+      } catch (err) {
+        resolve(SEARCH_ENGINE_PLACEHOLDER_ICON);
+      }
+    });
+  },
+
+  _ensureDataHasProperties(data, requiredProperties) {
+    for (let prop of requiredProperties) {
+      if (!(prop in data)) {
+        throw new Error("Message data missing required property: " + prop);
+      }
+    }
+  },
+
+  _initService() {
+    if (!this._initServicePromise) {
+      this._initServicePromise = Services.search.init();
+    }
+    return this._initServicePromise;
+  },
+};
+
+export class ContentSearchParent extends JSWindowActorParent {
+  constructor() {
+    super();
+    ContentSearch.init();
+    gContentSearchActors.add(this);
+  }
+
+  didDestroy() {
+    gContentSearchActors.delete(this);
+  }
+
+  receiveMessage(msg) {
+    // Add a temporary event handler that exists only while the message is in
+    // the event queue.  If the message's source docshell changes browsers in
+    // the meantime, then we need to update the browser.  event.detail will be
+    // the docshell's new parent <xul:browser> element.
+    let browser = this.browsingContext.top.embedderElement;
+    let eventItem = {
+      type: "Message",
+      name: msg.name,
+      data: msg.data,
+      browser,
+      actor: this,
+      handleEvent: event => {
+        let browserData = ContentSearch._suggestionMap.get(eventItem.browser);
+        if (browserData) {
+          ContentSearch._suggestionMap.delete(eventItem.browser);
+          ContentSearch._suggestionMap.set(event.detail, browserData);
+        }
+        browser.removeEventListener("SwapDocShells", eventItem, true);
+        eventItem.browser = event.detail;
+        eventItem.browser.addEventListener("SwapDocShells", eventItem, true);
+      },
+    };
+    browser.addEventListener("SwapDocShells", eventItem, true);
+
+    // Search requests cause cancellation of all Suggestion requests from the
+    // same browser.
+    if (msg.name === "Search") {
+      ContentSearch._cancelSuggestions(eventItem);
+    }
+
+    ContentSearch._eventQueue.push(eventItem);
+    ContentSearch._processEventQueue();
+  }
+}