tor-browser

ext-find.js (8908B)

---

/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=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/. */

/* global tabTracker */
"use strict";

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

var { ExtensionError } = ExtensionUtils;

// A mapping of top-level ExtFind actors to arrays of results in each subframe.
let findResults = new WeakMap();

function getActorForBrowsingContext(browsingContext) {
 let windowGlobal = browsingContext.currentWindowGlobal;
 return windowGlobal ? windowGlobal.getActor("ExtFind") : null;
}

function getTopLevelActor(browser) {
 return getActorForBrowsingContext(browser.browsingContext);
}

function gatherActors(browsingContext) {
 let list = [];

 let actor = getActorForBrowsingContext(browsingContext);
 if (actor) {
   list.push({ actor, result: null });
 }

 let children = browsingContext.children;
 for (let child of children) {
   list.push(...gatherActors(child));
 }

 return list;
}

function mergeFindResults(params, list) {
 let finalResult = {
   count: 0,
 };

 if (params.includeRangeData) {
   finalResult.rangeData = [];
 }
 if (params.includeRectData) {
   finalResult.rectData = [];
 }

 let currentFramePos = -1;
 for (let item of list) {
   if (item.result.count == 0) {
     continue;
   }

   // The framePos is incremented for each different document that has matches.
   currentFramePos++;

   finalResult.count += item.result.count;
   if (params.includeRangeData && item.result.rangeData) {
     for (let range of item.result.rangeData) {
       range.framePos = currentFramePos;
     }

     finalResult.rangeData.push(...item.result.rangeData);
   }

   if (params.includeRectData && item.result.rectData) {
     finalResult.rectData.push(...item.result.rectData);
   }
 }

 return finalResult;
}

function sendMessageToAllActors(browser, message, params) {
 for (let { actor } of gatherActors(browser.browsingContext)) {
   actor.sendAsyncMessage("ext-Finder:" + message, params);
 }
}

async function getFindResultsForActor(findContext, message, params) {
 findContext.result = await findContext.actor.sendQuery(
   "ext-Finder:" + message,
   params
 );
 return findContext;
}

function queryAllActors(browser, message, params) {
 let promises = [];
 for (let findContext of gatherActors(browser.browsingContext)) {
   promises.push(getFindResultsForActor(findContext, message, params));
 }
 return Promise.all(promises);
}

async function collectFindResults(browser, findResults, params) {
 let results = await queryAllActors(browser, "CollectResults", params);
 findResults.set(getTopLevelActor(browser), results);
 return mergeFindResults(params, results);
}

async function runHighlight(browser, params) {
 let hasResults = false;
 let foundResults = false;
 let list = findResults.get(getTopLevelActor(browser));
 if (!list) {
   return Promise.reject({ message: "no search results to highlight" });
 }

 let highlightPromises = [];

 let index = params.rangeIndex;
 const highlightAll = typeof index != "number";

 for (let c = 0; c < list.length; c++) {
   if (list[c].result.count) {
     hasResults = true;
   }

   let actor = list[c].actor;
   if (highlightAll) {
     // Highlight all ranges.
     highlightPromises.push(
       actor.sendQuery("ext-Finder:HighlightResults", params)
     );
   } else if (!foundResults && index < list[c].result.count) {
     foundResults = true;
     params.rangeIndex = index;
     highlightPromises.push(
       actor.sendQuery("ext-Finder:HighlightResults", params)
     );
   } else {
     highlightPromises.push(
       actor.sendQuery("ext-Finder:ClearHighlighting", params)
     );
   }

   index -= list[c].result.count;
 }

 let responses = await Promise.all(highlightPromises);
 if (hasResults) {
   if (responses.includes("OutOfRange") || index >= 0) {
     return Promise.reject({ message: "index supplied was out of range" });
   } else if (responses.includes("Success")) {
     return;
   }
 }

 return Promise.reject({ message: "no search results to highlight" });
}

/**
* runFindOperation
* Utility for `find` and `highlightResults`.
*
* @param {BaseContext} context - context the find operation runs in.
* @param {object} params - params to pass to message sender.
* @param {string} message - identifying component of message name.
*
* @returns {Promise} a promise that will be resolved or rejected based on the
*          data received by the message listener.
*/
function runFindOperation(context, params, message) {
 let { tabId } = params;
 let tab = tabId ? tabTracker.getTab(tabId) : tabTracker.activeTab;
 let browser = tab.linkedBrowser;
 tabId = tabId || tabTracker.getId(tab);
 if (
   !context.privateBrowsingAllowed &&
   PrivateBrowsingUtils.isBrowserPrivate(browser)
 ) {
   return Promise.reject({ message: `Unable to search: ${tabId}` });
 }
 // We disallow find in about: urls.
 if (
   tab.linkedBrowser.contentPrincipal.isSystemPrincipal ||
   (["about", "chrome", "resource"].includes(
     tab.linkedBrowser.currentURI.scheme
   ) &&
     tab.linkedBrowser.currentURI.spec != "about:blank")
 ) {
   return Promise.reject({ message: `Unable to search: ${tabId}` });
 }

 if (message == "HighlightResults") {
   return runHighlight(browser, params);
 } else if (message == "CollectResults") {
   // Remove prior highlights before starting a new find operation.
   findResults.delete(getTopLevelActor(browser));
   return collectFindResults(browser, findResults, params);
 }
}

this.find = class extends ExtensionAPI {
 getAPI(context) {
   return {
     find: {
       /**
        * browser.find.find
        * Searches document and its frames for a given queryphrase and stores all found
        * Range objects in an array accessible by other browser.find methods.
        *
        * @param {string} queryphrase - The string to search for.
        * @param {object} params optional - may contain any of the following properties,
        *   all of which are optional:
        *   {number} tabId - Tab to query.  Defaults to the active tab.
        *   {boolean} caseSensitive - Highlight only ranges with case sensitive match.
        *   {boolean} entireWord - Highlight only ranges that match entire word.
        *   {boolean} includeRangeData - Whether to return range data.
        *   {boolean} includeRectData - Whether to return rectangle data.
        *
        * @returns {object} data received by the message listener that includes:
        *   {number} count - number of results found.
        *   {array} rangeData (if opted) - serialized representation of ranges found.
        *   {array} rectData (if opted) - rect data of ranges found.
        */
       find(queryphrase, params) {
         params = params || {};
         params.queryphrase = queryphrase;
         return runFindOperation(context, params, "CollectResults");
       },

       /**
        * browser.find.highlightResults
        * Highlights range(s) found in previous browser.find.find.
        *
        * @param {object} params optional - may contain any of the following properties,
        *   all of which are optional:
        *   {number} rangeIndex - Found range to be highlighted. Default highlights all ranges.
        *   {number} tabId - Tab to highlight.  Defaults to the active tab.
        *   {boolean} noScroll - Don't scroll to highlighted item.
        *
        * @returns {string} - data received by the message listener that may be:
        *   "Success" - Highlighting succeeded.
        *   "OutOfRange" - The index supplied was out of range.
        *   "NoResults" - There were no search results to highlight.
        */
       highlightResults(params) {
         params = params || {};
         return runFindOperation(context, params, "HighlightResults");
       },

       /**
        * browser.find.removeHighlighting
        * Removes all highlighting from previous search.
        *
        * @param {number} tabId optional
        *                 Tab to clear highlighting in.  Defaults to the active tab.
        */
       removeHighlighting(tabId) {
         let tab = tabId ? tabTracker.getTab(tabId) : tabTracker.activeTab;
         if (
           !context.privateBrowsingAllowed &&
           PrivateBrowsingUtils.isBrowserPrivate(tab.linkedBrowser)
         ) {
           throw new ExtensionError(`Invalid tab ID: ${tabId}`);
         }
         sendMessageToAllActors(tab.linkedBrowser, "ClearHighlighting", {});
       },
     },
   };
 }
};