path: root/toolkit/modules/tests/browser/head.js

"use strict";

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

const kFixtureBaseURL =
  "https://example.com/browser/toolkit/modules/tests/browser/";

function removeDupes(list) {
  let j = 0;
  for (let i = 1; i < list.length; i++) {
    if (list[i] != list[j]) {
      j++;
      if (i != j) {
        list[j] = list[i];
      }
    }
  }
  list.length = j + 1;
}

function compareLists(list1, list2, kind) {
  list1.sort();
  removeDupes(list1);
  list2.sort();
  removeDupes(list2);
  is(String(list1), String(list2), `${kind} URLs correct`);
}

async function promiseOpenFindbar(findbar) {
  await gBrowser.getFindBar();
  findbar.onFindCommand();
  return gFindBar._startFindDeferred && gFindBar._startFindDeferred.promise;
}

function promiseFindResult(findbar, str = null) {
  let highlightFinished = false;
  let findFinished = false;
  return new Promise(resolve => {
    let listener = {
      onFindResult({ searchString }) {
        if (str !== null && str != searchString) {
          return;
        }
        findFinished = true;
        if (highlightFinished) {
          findbar.browser.finder.removeResultListener(listener);
          resolve();
        }
      },
      onHighlightFinished() {
        highlightFinished = true;
        if (findFinished) {
          findbar.browser.finder.removeResultListener(listener);
          resolve();
        }
      },
      onMatchesCountResult: () => {},
    };
    findbar.browser.finder.addResultListener(listener);
  });
}

function promiseEnterStringIntoFindField(findbar, str) {
  let promise = promiseFindResult(findbar, str);
  for (let i = 0; i < str.length; i++) {
    let event = new KeyboardEvent("keypress", {
      bubbles: true,
      cancelable: true,
      view: null,
      keyCode: 0,
      charCode: str.charCodeAt(i),
    });
    findbar._findField.dispatchEvent(event);
  }
  return promise;
}

function promiseTestHighlighterOutput(
  browser,
  word,
  expectedResult,
  extraTest = () => {}
) {
  return SpecialPowers.spawn(
    browser,
    [{ word, expectedResult, extraTest: extraTest.toSource() }],
    async function({ word, expectedResult, extraTest }) {
      return new Promise((resolve, reject) => {
        let stubbed = {};
        let callCounts = {
          insertCalls: [],
          removeCalls: [],
          animationCalls: [],
        };
        let lastMaskNode, lastOutlineNode;
        let rects = [];

        // Amount of milliseconds to wait after the last time one of our stubs
        // was called.
        const kTimeoutMs = 1000;
        // The initial timeout may wait for a while for results to come in.
        let timeout = content.setTimeout(
          () => finish(false, "Timeout"),
          kTimeoutMs * 5
        );

        function finish(ok = true, message = "finished with error") {
          // Restore the functions we stubbed out.
          try {
            content.document.insertAnonymousContent = stubbed.insert;
            content.document.removeAnonymousContent = stubbed.remove;
          } catch (ex) {}
          stubbed = {};
          content.clearTimeout(timeout);

          if (expectedResult.rectCount !== 0) {
            Assert.ok(ok, message);
          }

          Assert.greaterOrEqual(
            callCounts.insertCalls.length,
            expectedResult.insertCalls[0],
            `Min. insert calls should match for '${word}'.`
          );
          Assert.lessOrEqual(
            callCounts.insertCalls.length,
            expectedResult.insertCalls[1],
            `Max. insert calls should match for '${word}'.`
          );
          Assert.greaterOrEqual(
            callCounts.removeCalls.length,
            expectedResult.removeCalls[0],
            `Min. remove calls should match for '${word}'.`
          );
          Assert.lessOrEqual(
            callCounts.removeCalls.length,
            expectedResult.removeCalls[1],
            `Max. remove calls should match for '${word}'.`
          );

          // We reached the amount of calls we expected, so now we can check
          // the amount of rects.
          if (!lastMaskNode && expectedResult.rectCount !== 0) {
            Assert.ok(
              false,
              `No mask node found, but expected ${expectedResult.rectCount} rects.`
            );
          }

          Assert.equal(
            rects.length,
            expectedResult.rectCount,
            `Amount of inserted rects should match for '${word}'.`
          );

          if ("animationCalls" in expectedResult) {
            Assert.greaterOrEqual(
              callCounts.animationCalls.length,
              expectedResult.animationCalls[0],
              `Min. animation calls should match for '${word}'.`
            );
            Assert.lessOrEqual(
              callCounts.animationCalls.length,
              expectedResult.animationCalls[1],
              `Max. animation calls should match for '${word}'.`
            );
          }

          // Allow more specific assertions to be tested in `extraTest`.
          // eslint-disable-next-line no-eval
          extraTest = eval(extraTest);
          extraTest(lastMaskNode, lastOutlineNode, rects);

          resolve();
        }

        function stubAnonymousContentNode(domNode, anonNode) {
          let originals = [
            anonNode.setTextContentForElement,
            anonNode.setAttributeForElement,
            anonNode.removeAttributeForElement,
            anonNode.setCutoutRectsForElement,
            anonNode.setAnimationForElement,
          ];
          anonNode.setTextContentForElement = (id, text) => {
            try {
              (domNode.querySelector("#" + id) || domNode).textContent = text;
            } catch (ex) {}
            return originals[0].call(anonNode, id, text);
          };
          anonNode.setAttributeForElement = (id, attrName, attrValue) => {
            try {
              (domNode.querySelector("#" + id) || domNode).setAttribute(
                attrName,
                attrValue
              );
            } catch (ex) {}
            return originals[1].call(anonNode, id, attrName, attrValue);
          };
          anonNode.removeAttributeForElement = (id, attrName) => {
            try {
              let node = domNode.querySelector("#" + id) || domNode;
              if (node.hasAttribute(attrName)) {
                node.removeAttribute(attrName);
              }
            } catch (ex) {}
            return originals[2].call(anonNode, id, attrName);
          };
          anonNode.setCutoutRectsForElement = (id, cutoutRects) => {
            rects = cutoutRects;
            return originals[3].call(anonNode, id, cutoutRects);
          };
          anonNode.setAnimationForElement = (id, keyframes, options) => {
            callCounts.animationCalls.push([keyframes, options]);
            return originals[4].call(anonNode, id, keyframes, options);
          };
        }

        // Create a function that will stub the original version and collects
        // the arguments so we can check the results later.
        function stub(which) {
          stubbed[which] = content.document[which + "AnonymousContent"];
          let prop = which + "Calls";
          return function(node) {
            callCounts[prop].push(node);
            if (which == "insert") {
              if (node.outerHTML.indexOf("outlineMask") > -1) {
                lastMaskNode = node;
              } else {
                lastOutlineNode = node;
              }
            }
            content.clearTimeout(timeout);
            timeout = content.setTimeout(() => {
              finish();
            }, kTimeoutMs);
            let res = stubbed[which].call(content.document, node);
            if (which == "insert") {
              stubAnonymousContentNode(node, res);
            }
            return res;
          };
        }
        content.document.insertAnonymousContent = stub("insert");
        content.document.removeAnonymousContent = stub("remove");
      });
    }
  );
}