summaryrefslogtreecommitdiffstats
path: root/toolkit/modules/FinderParent.sys.mjs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /toolkit/modules/FinderParent.sys.mjs
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/modules/FinderParent.sys.mjs')
-rw-r--r--toolkit/modules/FinderParent.sys.mjs654
1 files changed, 654 insertions, 0 deletions
diff --git a/toolkit/modules/FinderParent.sys.mjs b/toolkit/modules/FinderParent.sys.mjs
new file mode 100644
index 0000000000..8c8437f5e9
--- /dev/null
+++ b/toolkit/modules/FinderParent.sys.mjs
@@ -0,0 +1,654 @@
+// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
+// vim: set ts=2 sw=2 sts=2 et tw=80: */
+// 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 kModalHighlightPref = "findbar.modalHighlight";
+const kSoundEnabledPref = "accessibility.typeaheadfind.enablesound";
+const kNotFoundSoundPref = "accessibility.typeaheadfind.soundURL";
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ GetClipboardSearchString: "resource://gre/modules/Finder.sys.mjs",
+ RFPHelper: "resource://gre/modules/RFPHelper.sys.mjs",
+ Rect: "resource://gre/modules/Geometry.sys.mjs",
+});
+
+const kPrefLetterboxing = "privacy.resistFingerprinting.letterboxing";
+
+XPCOMUtils.defineLazyPreferenceGetter(
+ lazy,
+ "isLetterboxingEnabled",
+ kPrefLetterboxing,
+ false
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+ lazy,
+ "isSoundEnabled",
+ kSoundEnabledPref,
+ false
+);
+
+XPCOMUtils.defineLazyPreferenceGetter(
+ lazy,
+ "notFoundSoundURL",
+ kNotFoundSoundPref,
+ ""
+);
+
+export function FinderParent(browser) {
+ this._listeners = new Set();
+ this._searchString = "";
+ this._foundSearchString = null;
+ this._lastFoundBrowsingContext = null;
+
+ // The correct states of these will be updated when the findbar is opened.
+ this._caseSensitive = false;
+ this._entireWord = false;
+ this._matchDiacritics = false;
+
+ this.swapBrowser(browser);
+}
+
+let gSound = null;
+
+FinderParent.prototype = {
+ get browsingContext() {
+ return this._browser.browsingContext;
+ },
+
+ get useRemoteSubframes() {
+ return this._browser.ownerGlobal.docShell.nsILoadContext.useRemoteSubframes;
+ },
+
+ swapBrowser(aBrowser) {
+ this._browser = aBrowser;
+ // Ideally listeners would have removed themselves but that doesn't happen
+ // right now
+ this._listeners.clear();
+ },
+
+ addResultListener(aListener) {
+ this._listeners.add(aListener);
+ },
+
+ removeResultListener(aListener) {
+ this._listeners.delete(aListener);
+ },
+
+ callListeners(aCallback, aArgs) {
+ for (let l of this._listeners) {
+ // Don't let one callback throwing stop us calling the rest
+ try {
+ l[aCallback].apply(l, aArgs);
+ } catch (e) {
+ if (!l[aCallback]) {
+ console.error(
+ `Missing ${aCallback} callback on RemoteFinderListener`
+ );
+ } else {
+ console.error(e);
+ }
+ }
+ }
+ },
+
+ getLastFoundBrowsingContext(aList) {
+ // If a search was already performed, returned the last
+ // browsing context where the result was found. However,
+ // ensure that this browsing context is still valid, and
+ // if not, return null.
+ if (
+ aList.includes(this._lastFoundBrowsingContext) &&
+ !this._lastFoundBrowsingContext.isUnderHiddenEmbedderElement
+ ) {
+ return this._lastFoundBrowsingContext;
+ }
+
+ this._lastFoundBrowsingContext = null;
+ return null;
+ },
+
+ sendMessageToContext(aMessageName, aArgs = {}) {
+ // If there is a last found browsing context, use that. Otherwise,
+ // use the top-level browsing context.
+ let browsingContext = null;
+ if (this._lastFoundBrowsingContext) {
+ let list = this.gatherBrowsingContexts(this.browsingContext);
+ let lastBrowsingContext = this.getLastFoundBrowsingContext(list);
+ if (lastBrowsingContext) {
+ browsingContext = lastBrowsingContext;
+ }
+ }
+
+ if (!browsingContext) {
+ browsingContext = this.browsingContext;
+ }
+
+ let windowGlobal = browsingContext.currentWindowGlobal;
+ if (windowGlobal) {
+ let actor = windowGlobal.getActor("Finder");
+ actor.sendAsyncMessage(aMessageName, aArgs);
+ }
+ },
+
+ sendQueryToContext(aMessageName, aArgs, aBrowsingContext) {
+ let windowGlobal = aBrowsingContext.currentWindowGlobal;
+ if (windowGlobal) {
+ let actor = windowGlobal.getActor("Finder");
+ return actor.sendQuery(aMessageName, aArgs).then(
+ result => result,
+ r => {}
+ );
+ }
+
+ return Promise.resolve({});
+ },
+
+ sendMessageToAllContexts(aMessageName, aArgs = {}) {
+ let list = this.gatherBrowsingContexts(this.browsingContext);
+ for (let browsingContext of list) {
+ let windowGlobal = browsingContext.currentWindowGlobal;
+ if (windowGlobal) {
+ let actor = windowGlobal.getActor("Finder");
+ actor.sendAsyncMessage(aMessageName, aArgs);
+ }
+ }
+ },
+
+ gatherBrowsingContexts(aBrowsingContext) {
+ if (aBrowsingContext.isUnderHiddenEmbedderElement) {
+ return [];
+ }
+
+ let list = [aBrowsingContext];
+
+ for (let child of aBrowsingContext.children) {
+ list.push(...this.gatherBrowsingContexts(child));
+ }
+
+ return list;
+ },
+
+ // If the modal highlighter is on, and there are no out-of-process child
+ // frames, send a message only to the top-level frame and set the useSubFrames
+ // flag, so that the finder iterator iterates over subframes. If there is
+ // an out-of-process subframe, modal highlighting is disabled.
+ needSubFrameSearch(aList) {
+ let useSubFrames = false;
+
+ let useModalHighlighter = Services.prefs.getBoolPref(kModalHighlightPref);
+ let hasOutOfProcessChild = false;
+ if (useModalHighlighter) {
+ if (this.useRemoteSubframes) {
+ return false;
+ }
+
+ for (let browsingContext of aList) {
+ if (
+ browsingContext != this.browsingContext &&
+ browsingContext.currentWindowGlobal.isProcessRoot
+ ) {
+ hasOutOfProcessChild = true;
+ }
+ }
+
+ if (!hasOutOfProcessChild) {
+ aList.splice(0);
+ aList.push(this.browsingContext);
+ useSubFrames = true;
+ }
+ }
+
+ return useSubFrames;
+ },
+
+ onResultFound(aResponse) {
+ this._foundSearchString = aResponse.searchString;
+ // The rect stops being a Geometry.sys.mjs:Rect over IPC.
+ if (aResponse.rect) {
+ aResponse.rect = lazy.Rect.fromRect(aResponse.rect);
+ }
+
+ this.callListeners("onFindResult", [aResponse]);
+ },
+
+ get searchString() {
+ return this._foundSearchString;
+ },
+
+ get clipboardSearchString() {
+ return lazy.GetClipboardSearchString(this._browser.loadContext);
+ },
+
+ set caseSensitive(aSensitive) {
+ this._caseSensitive = aSensitive;
+ this.sendMessageToAllContexts("Finder:CaseSensitive", {
+ caseSensitive: aSensitive,
+ });
+ },
+
+ set entireWord(aEntireWord) {
+ this._entireWord = aEntireWord;
+ this.sendMessageToAllContexts("Finder:EntireWord", {
+ entireWord: aEntireWord,
+ });
+ },
+
+ set matchDiacritics(aMatchDiacritics) {
+ this._matchDiacritics = aMatchDiacritics;
+ this.sendMessageToAllContexts("Finder:MatchDiacritics", {
+ matchDiacritics: aMatchDiacritics,
+ });
+ },
+
+ async setSearchStringToSelection() {
+ return this.setToSelection("Finder:SetSearchStringToSelection", false);
+ },
+
+ async getInitialSelection() {
+ return this.setToSelection("Finder:GetInitialSelection", true);
+ },
+
+ async setToSelection(aMessage, aInitial) {
+ let browsingContext = this.browsingContext;
+
+ // Iterate over focused subframe descendants until one is found
+ // that has the selection.
+ let result;
+ do {
+ result = await this.sendQueryToContext(aMessage, {}, browsingContext);
+ if (!result || !result.focusedChildBrowserContextId) {
+ break;
+ }
+
+ browsingContext = BrowsingContext.get(
+ result.focusedChildBrowserContextId
+ );
+ } while (browsingContext);
+
+ if (result) {
+ this.callListeners("onCurrentSelection", [result.selectedText, aInitial]);
+ }
+
+ return result;
+ },
+
+ async doFind(aFindNext, aArgs) {
+ let rootBC = this.browsingContext;
+ let highlightList = this.gatherBrowsingContexts(rootBC);
+
+ let canPlayNotFoundSound =
+ aArgs.searchString.length > this._searchString.length;
+
+ this._searchString = aArgs.searchString;
+
+ let initialBC = this.getLastFoundBrowsingContext(highlightList);
+ if (!initialBC) {
+ initialBC = rootBC;
+ aFindNext = false;
+ }
+
+ // Make a copy of the list starting from the
+ // browsing context that was last searched from. The original
+ // list will be used for the highlighter where the search
+ // order doesn't matter.
+ let searchList = [];
+ for (let c = 0; c < highlightList.length; c++) {
+ if (highlightList[c] == initialBC) {
+ searchList = highlightList.slice(c);
+ searchList.push(...highlightList.slice(0, c));
+ break;
+ }
+ }
+
+ let mode = Ci.nsITypeAheadFind.FIND_INITIAL;
+ if (aFindNext) {
+ mode = aArgs.findBackwards
+ ? Ci.nsITypeAheadFind.FIND_PREVIOUS
+ : Ci.nsITypeAheadFind.FIND_NEXT;
+ }
+ aArgs.findAgain = aFindNext;
+
+ aArgs.caseSensitive = this._caseSensitive;
+ aArgs.matchDiacritics = this._matchDiacritics;
+ aArgs.entireWord = this._entireWord;
+
+ aArgs.useSubFrames = this.needSubFrameSearch(searchList);
+ if (aArgs.useSubFrames) {
+ // Use the single frame for the highlight list as well.
+ highlightList = searchList;
+ // The typeaheadfind component will play the sound in this case.
+ canPlayNotFoundSound = false;
+ }
+
+ if (canPlayNotFoundSound) {
+ this.initNotFoundSound();
+ }
+
+ // Add the initial browsing context twice to allow looping around.
+ searchList = [...searchList, initialBC];
+
+ if (aArgs.findBackwards) {
+ searchList.reverse();
+ }
+
+ let response = null;
+ let wrapped = false;
+ let foundBC = null;
+
+ for (let c = 0; c < searchList.length; c++) {
+ let currentBC = searchList[c];
+ aArgs.mode = mode;
+
+ // A search has started for a different string, so
+ // ignore further searches of the old string.
+ if (this._searchString != aArgs.searchString) {
+ return;
+ }
+
+ response = await this.sendQueryToContext("Finder:Find", aArgs, currentBC);
+
+ // This can happen if the tab is closed while the find is in progress.
+ if (!response) {
+ break;
+ }
+
+ // If the search term was found, stop iterating.
+ if (response.result != Ci.nsITypeAheadFind.FIND_NOTFOUND) {
+ if (
+ this._lastFoundBrowsingContext &&
+ this._lastFoundBrowsingContext != currentBC
+ ) {
+ // If the new result is in a different frame than the previous result,
+ // clear the result from the old frame. If it is the same frame, the
+ // previous result will be cleared by the find component.
+ this.removeSelection(true);
+ }
+ this._lastFoundBrowsingContext = currentBC;
+
+ // Set the wrapped result flag if needed.
+ if (wrapped) {
+ response.result = Ci.nsITypeAheadFind.FIND_WRAPPED;
+ }
+
+ foundBC = currentBC;
+ break;
+ }
+
+ if (aArgs.findBackwards && currentBC == rootBC) {
+ wrapped = true;
+ } else if (
+ !aArgs.findBackwards &&
+ c + 1 < searchList.length &&
+ searchList[c + 1] == rootBC
+ ) {
+ wrapped = true;
+ }
+
+ mode = aArgs.findBackwards
+ ? Ci.nsITypeAheadFind.FIND_LAST
+ : Ci.nsITypeAheadFind.FIND_FIRST;
+ }
+
+ if (response) {
+ response.useSubFrames = aArgs.useSubFrames;
+ // Update the highlight in all browsing contexts. This needs to happen separately
+ // once it is clear whether a match was found or not.
+ this.updateHighlightAndMatchCount({
+ list: highlightList,
+ message: "Finder:UpdateHighlightAndMatchCount",
+ args: response,
+ foundBrowsingContextId: foundBC ? foundBC.id : -1,
+ doHighlight: true,
+ doMatchCount: true,
+ });
+
+ // Use the last result found.
+ this.onResultFound(response);
+
+ if (
+ canPlayNotFoundSound &&
+ response.result == Ci.nsITypeAheadFind.FIND_NOTFOUND &&
+ !aFindNext &&
+ !response.entireWord
+ ) {
+ this.playNotFoundSound();
+ }
+ }
+ },
+
+ fastFind(aSearchString, aLinksOnly, aDrawOutline) {
+ this.doFind(false, {
+ searchString: aSearchString,
+ findBackwards: false,
+ linksOnly: aLinksOnly,
+ drawOutline: aDrawOutline,
+ });
+ },
+
+ findAgain(aSearchString, aFindBackwards, aLinksOnly, aDrawOutline) {
+ this.doFind(true, {
+ searchString: aSearchString,
+ findBackwards: aFindBackwards,
+ linksOnly: aLinksOnly,
+ drawOutline: aDrawOutline,
+ });
+ },
+
+ highlight(aHighlight, aWord, aLinksOnly) {
+ let list = this.gatherBrowsingContexts(this.browsingContext);
+ let args = {
+ highlight: aHighlight,
+ linksOnly: aLinksOnly,
+ searchString: aWord,
+ };
+
+ args.useSubFrames = this.needSubFrameSearch(list);
+
+ let lastBrowsingContext = this.getLastFoundBrowsingContext(list);
+ this.updateHighlightAndMatchCount({
+ list,
+ message: "Finder:Highlight",
+ args,
+ foundBrowsingContextId: lastBrowsingContext ? lastBrowsingContext.id : -1,
+ doHighlight: true,
+ doMatchCount: false,
+ });
+ },
+
+ requestMatchesCount(aSearchString, aLinksOnly) {
+ let list = this.gatherBrowsingContexts(this.browsingContext);
+ let args = { searchString: aSearchString, linksOnly: aLinksOnly };
+
+ args.useSubFrames = this.needSubFrameSearch(list);
+
+ let lastBrowsingContext = this.getLastFoundBrowsingContext(list);
+ this.updateHighlightAndMatchCount({
+ list,
+ message: "Finder:MatchesCount",
+ args,
+ foundBrowsingContextId: lastBrowsingContext ? lastBrowsingContext.id : -1,
+ doHighlight: false,
+ doMatchCount: true,
+ });
+ },
+
+ updateHighlightAndMatchCount(options) {
+ let promises = [];
+ let found = options.args.result != Ci.nsITypeAheadFind.FIND_NOTFOUND;
+ for (let browsingContext of options.list) {
+ options.args.foundInThisFrame =
+ options.foundBrowsingContextId != -1 &&
+ found &&
+ browsingContext.id == options.foundBrowsingContextId;
+
+ // Don't wait for the result
+ let promise = this.sendQueryToContext(
+ options.message,
+ options.args,
+ browsingContext
+ );
+ promises.push(promise);
+ }
+
+ Promise.all(promises).then(responses => {
+ if (options.doHighlight) {
+ let sendNotification = false;
+ let highlight = false;
+ let found = false;
+ for (let response of responses) {
+ if (!response) {
+ break;
+ }
+
+ sendNotification = true;
+ if (response.found) {
+ found = true;
+ }
+ highlight = response.highlight;
+ }
+
+ if (sendNotification) {
+ this.callListeners("onHighlightFinished", [
+ { searchString: options.args.searchString, highlight, found },
+ ]);
+ }
+ }
+
+ if (options.doMatchCount) {
+ let sendNotification = false;
+ let current = 0;
+ let total = 0;
+ let limit = 0;
+ for (let response of responses) {
+ // A null response can happen if another search was started
+ // and this one became invalid.
+ if (!response || !("total" in response)) {
+ break;
+ }
+
+ sendNotification = true;
+
+ if (
+ options.args.useSubFrames ||
+ (options.foundBrowsingContextId >= 0 &&
+ response.browsingContextId == options.foundBrowsingContextId)
+ ) {
+ current = total + response.current;
+ }
+ total += response.total;
+ limit = response.limit;
+ }
+
+ if (sendNotification) {
+ this.callListeners("onMatchesCountResult", [
+ { searchString: options.args.searchString, current, total, limit },
+ ]);
+ }
+ }
+ });
+ },
+
+ enableSelection() {
+ this.sendMessageToContext("Finder:EnableSelection");
+ },
+
+ removeSelection(aKeepHighlight) {
+ this.sendMessageToContext("Finder:RemoveSelection", {
+ keepHighlight: aKeepHighlight,
+ });
+ },
+
+ focusContent() {
+ // Allow Finder listeners to cancel focusing the content.
+ for (let l of this._listeners) {
+ try {
+ if ("shouldFocusContent" in l && !l.shouldFocusContent()) {
+ return;
+ }
+ } catch (ex) {
+ console.error(ex);
+ }
+ }
+
+ this._browser.focus();
+ this.sendMessageToContext("Finder:FocusContent");
+ },
+
+ onFindbarClose() {
+ this._lastFoundBrowsingContext = null;
+ this.sendMessageToAllContexts("Finder:FindbarClose");
+
+ if (lazy.isLetterboxingEnabled) {
+ let window = this._browser.ownerGlobal;
+ lazy.RFPHelper.contentSizeUpdated(window);
+ }
+ },
+
+ onFindbarOpen() {
+ this.sendMessageToAllContexts("Finder:FindbarOpen");
+
+ if (lazy.isLetterboxingEnabled) {
+ let window = this._browser.ownerGlobal;
+ lazy.RFPHelper.contentSizeUpdated(window);
+ }
+ },
+
+ onModalHighlightChange(aUseModalHighlight) {
+ this.sendMessageToAllContexts("Finder:ModalHighlightChange", {
+ useModalHighlight: aUseModalHighlight,
+ });
+ },
+
+ onHighlightAllChange(aHighlightAll) {
+ this.sendMessageToAllContexts("Finder:HighlightAllChange", {
+ highlightAll: aHighlightAll,
+ });
+ },
+
+ keyPress(aEvent) {
+ this.sendMessageToContext("Finder:KeyPress", {
+ keyCode: aEvent.keyCode,
+ ctrlKey: aEvent.ctrlKey,
+ metaKey: aEvent.metaKey,
+ altKey: aEvent.altKey,
+ shiftKey: aEvent.shiftKey,
+ });
+ },
+
+ initNotFoundSound() {
+ if (!gSound && lazy.isSoundEnabled && lazy.notFoundSoundURL) {
+ try {
+ gSound = Cc["@mozilla.org/sound;1"].getService(Ci.nsISound);
+ gSound.init();
+ } catch (ex) {}
+ }
+ },
+
+ playNotFoundSound() {
+ if (!lazy.isSoundEnabled || !lazy.notFoundSoundURL) {
+ return;
+ }
+
+ this.initNotFoundSound();
+ if (!gSound) {
+ return;
+ }
+
+ let soundUrl = lazy.notFoundSoundURL;
+ if (soundUrl == "beep") {
+ gSound.beep();
+ } else {
+ if (soundUrl == "default") {
+ soundUrl = "chrome://global/content/notfound.wav";
+ }
+ gSound.play(Services.io.newURI(soundUrl));
+ }
+ },
+};