Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

1 files changed, 933 insertions, 0 deletions

diff --git a/layout/style/test/animation_utils.js b/layout/style/test/animation_utils.js
new file mode 100644
index 0000000000..624ec2cc7a
--- /dev/null
+++ b/layout/style/test/animation_utils.js
@@ -0,0 +1,933 @@
+//----------------------------------------------------------------------
+//
+// Common testing functions
+//
+//----------------------------------------------------------------------
+
+function advance_clock(milliseconds) {
+  SpecialPowers.DOMWindowUtils.advanceTimeAndRefresh(milliseconds);
+}
+
+// Test-element creation/destruction and event checking
+(function () {
+  var gElem;
+  var gEventsReceived = [];
+
+  function new_div(style) {
+    return new_element("div", style);
+  }
+
+  // Creates a new |tagname| element with inline style |style| and appends
+  // it as a child of the element with ID 'display'.
+  // The element will also be given the class 'target' which can be used
+  // for additional styling.
+  function new_element(tagname, style) {
+    if (gElem) {
+      ok(false, "test author forgot to call done_div/done_elem");
+    }
+    if (typeof style != "string") {
+      ok(false, "test author forgot to pass argument");
+    }
+    if (!document.getElementById("display")) {
+      ok(false, "no 'display' element to append to");
+    }
+    gElem = document.createElement(tagname);
+    gElem.setAttribute("style", style);
+    gElem.classList.add("target");
+    document.getElementById("display").appendChild(gElem);
+    return [gElem, getComputedStyle(gElem, "")];
+  }
+
+  function listen() {
+    if (!gElem) {
+      ok(false, "test author forgot to call new_div before listen");
+    }
+    gEventsReceived = [];
+    function listener(event) {
+      gEventsReceived.push(event);
+    }
+    gElem.addEventListener("animationstart", listener);
+    gElem.addEventListener("animationiteration", listener);
+    gElem.addEventListener("animationend", listener);
+  }
+
+  function check_events(eventsExpected, desc) {
+    // This function checks that the list of eventsExpected matches
+    // the received events -- but it only checks the properties that
+    // are present on eventsExpected.
+    is(
+      gEventsReceived.length,
+      eventsExpected.length,
+      "number of events received for " + desc
+    );
+    for (
+      var i = 0,
+        i_end = Math.min(eventsExpected.length, gEventsReceived.length);
+      i != i_end;
+      ++i
+    ) {
+      var exp = eventsExpected[i];
+      var rec = gEventsReceived[i];
+      for (var prop in exp) {
+        if (prop == "elapsedTime") {
+          // Allow floating point error.
+          ok(
+            Math.abs(rec.elapsedTime - exp.elapsedTime) < 0.000002,
+            "events[" +
+              i +
+              "]." +
+              prop +
+              " for " +
+              desc +
+              " received=" +
+              rec.elapsedTime +
+              " expected=" +
+              exp.elapsedTime
+          );
+        } else {
+          is(
+            rec[prop],
+            exp[prop],
+            "events[" + i + "]." + prop + " for " + desc
+          );
+        }
+      }
+    }
+    for (var i = eventsExpected.length; i < gEventsReceived.length; ++i) {
+      ok(false, "unexpected " + gEventsReceived[i].type + " event for " + desc);
+    }
+    gEventsReceived = [];
+  }
+
+  function done_element() {
+    if (!gElem) {
+      ok(
+        false,
+        "test author called done_element/done_div without matching" +
+          " call to new_element/new_div"
+      );
+    }
+    gElem.remove();
+    gElem = null;
+    if (gEventsReceived.length) {
+      ok(false, "caller should have called check_events");
+    }
+  }
+
+  [new_div, new_element, listen, check_events, done_element].forEach(function (
+    fn
+  ) {
+    window[fn.name] = fn;
+  });
+  window.done_div = done_element;
+})();
+
+function px_to_num(str) {
+  return Number(String(str).match(/^([\d.]+)px$/)[1]);
+}
+
+function bezier(x1, y1, x2, y2) {
+  // Cubic bezier with control points (0, 0), (x1, y1), (x2, y2), and (1, 1).
+  function x_for_t(t) {
+    var omt = 1 - t;
+    return 3 * omt * omt * t * x1 + 3 * omt * t * t * x2 + t * t * t;
+  }
+  function y_for_t(t) {
+    var omt = 1 - t;
+    return 3 * omt * omt * t * y1 + 3 * omt * t * t * y2 + t * t * t;
+  }
+  function t_for_x(x) {
+    // Binary subdivision.
+    var mint = 0,
+      maxt = 1;
+    for (var i = 0; i < 30; ++i) {
+      var guesst = (mint + maxt) / 2;
+      var guessx = x_for_t(guesst);
+      if (x < guessx) {
+        maxt = guesst;
+      } else {
+        mint = guesst;
+      }
+    }
+    return (mint + maxt) / 2;
+  }
+  return function bezier_closure(x) {
+    if (x == 0) {
+      return 0;
+    }
+    if (x == 1) {
+      return 1;
+    }
+    return y_for_t(t_for_x(x));
+  };
+}
+
+function step_end(nsteps) {
+  return function step_end_closure(x) {
+    return Math.floor(x * nsteps) / nsteps;
+  };
+}
+
+function step_start(nsteps) {
+  var stepend = step_end(nsteps);
+  return function step_start_closure(x) {
+    return 1.0 - stepend(1.0 - x);
+  };
+}
+
+var gTF = {
+  ease: bezier(0.25, 0.1, 0.25, 1),
+  linear: function (x) {
+    return x;
+  },
+  ease_in: bezier(0.42, 0, 1, 1),
+  ease_out: bezier(0, 0, 0.58, 1),
+  ease_in_out: bezier(0.42, 0, 0.58, 1),
+  step_start: step_start(1),
+  step_end: step_end(1),
+};
+
+function is_approx(float1, float2, error, desc) {
+  ok(
+    Math.abs(float1 - float2) < error,
+    desc + ": " + float1 + " and " + float2 + " should be within " + error
+  );
+}
+
+function findKeyframesRule(name) {
+  for (var i = 0; i < document.styleSheets.length; i++) {
+    var match = [].find.call(document.styleSheets[i].cssRules, function (rule) {
+      return rule.type == CSSRule.KEYFRAMES_RULE && rule.name == name;
+    });
+    if (match) {
+      return match;
+    }
+  }
+  return undefined;
+}
+
+// Checks if off-main thread animation (OMTA) is available, and if it is, runs
+// the provided callback function. If OMTA is not available or is not
+// functioning correctly, the second callback, aOnSkip, is run instead.
+//
+// This function also does an internal test to verify that OMTA is working at
+// all so that if OMTA is not functioning correctly when it is expected to
+// function only a single failure is produced.
+//
+// Since this function relies on various asynchronous operations, the caller is
+// responsible for calling SimpleTest.waitForExplicitFinish() before calling
+// this and SimpleTest.finish() within aTestFunction and aOnSkip.
+//
+// specialPowersForPrefs exists because some SpecialPowers objects apparently
+// can get prefs and some can't; callers that would normally have one of the
+// latter but can get their hands on one of the former can pass it in
+// explicitly.
+function runOMTATest(aTestFunction, aOnSkip, specialPowersForPrefs) {
+  const OMTAPrefKey = "layers.offmainthreadcomposition.async-animations";
+  var utils = SpecialPowers.DOMWindowUtils;
+  if (!specialPowersForPrefs) {
+    specialPowersForPrefs = SpecialPowers;
+  }
+  var expectOMTA =
+    utils.layerManagerRemote &&
+    // ^ Off-main thread animation cannot be used if off-main
+    // thread composition (OMTC) is not available
+    specialPowersForPrefs.getBoolPref(OMTAPrefKey);
+
+  isOMTAWorking()
+    .then(function (isWorking) {
+      if (expectOMTA) {
+        if (isWorking) {
+          aTestFunction();
+        } else {
+          // We only call this when we know it will fail as otherwise in the
+          // regular success case we will end up inflating the "passed tests"
+          // count by 1
+          ok(isWorking, "OMTA should work");
+          aOnSkip();
+        }
+      } else {
+        todo(
+          isWorking,
+          "OMTA should ideally work, though we don't expect it to work on " +
+            "this platform/configuration"
+        );
+        aOnSkip();
+      }
+    })
+    .catch(function (err) {
+      ok(false, err);
+      aOnSkip();
+    });
+
+  function isOMTAWorking() {
+    // Create keyframes rule
+    const animationName = "a6ce3091ed85"; // Random name to avoid clashes
+    var ruleText =
+      "@keyframes " +
+      animationName +
+      " { from { opacity: 0.5 } to { opacity: 0.5 } }";
+    var style = document.createElement("style");
+    style.appendChild(document.createTextNode(ruleText));
+    document.head.appendChild(style);
+
+    // Create animation target
+    var div = document.createElement("div");
+    document.body.appendChild(div);
+
+    // Give the target geometry so it is eligible for layerization
+    div.style.width = "100px";
+    div.style.height = "100px";
+    div.style.backgroundColor = "white";
+
+    // Common clean up code
+    var cleanUp = function () {
+      div.remove();
+      style.remove();
+      if (utils.isTestControllingRefreshes) {
+        utils.restoreNormalRefresh();
+      }
+    };
+
+    return waitForDocumentLoad()
+      .then(loadPaintListener)
+      .then(function () {
+        // Put refresh driver under test control and flush all pending style,
+        // layout and paint to avoid the situation that waitForPaintsFlush()
+        // receives unexpected MozAfterpaint event for those pending
+        // notifications.
+        utils.advanceTimeAndRefresh(0);
+        return waitForPaintsFlushed();
+      })
+      .then(function () {
+        div.style.animation = animationName + " 10s";
+
+        return waitForPaintsFlushed();
+      })
+      .then(function () {
+        var opacity = utils.getOMTAStyle(div, "opacity");
+        cleanUp();
+        return Promise.resolve(opacity == 0.5);
+      })
+      .catch(function (err) {
+        cleanUp();
+        return Promise.reject(err);
+      });
+  }
+
+  function waitForDocumentLoad() {
+    return new Promise(function (resolve, reject) {
+      if (document.readyState === "complete") {
+        resolve();
+      } else {
+        window.addEventListener("load", resolve);
+      }
+    });
+  }
+
+  function loadPaintListener() {
+    return new Promise(function (resolve, reject) {
+      if (typeof window.waitForAllPaints !== "function") {
+        var script = document.createElement("script");
+        script.onload = resolve;
+        script.onerror = function () {
+          reject(new Error("Failed to load paint listener"));
+        };
+        script.src = "/tests/SimpleTest/paint_listener.js";
+        var firstScript = document.scripts[0];
+        firstScript.parentNode.insertBefore(script, firstScript);
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+// Common architecture for setting up a series of asynchronous animation tests
+//
+// Usage example:
+//
+//    addAsyncAnimTest(function *() {
+//       .. do work ..
+//       yield functionThatReturnsAPromise();
+//       .. do work ..
+//    });
+//    runAllAsyncAnimTests().then(SimpleTest.finish());
+//
+(function () {
+  var tests = [];
+
+  window.addAsyncAnimTest = function (generator) {
+    tests.push(generator);
+  };
+
+  // Returns a promise when all tests have run
+  window.runAllAsyncAnimTests = function (aOnAbort) {
+    // runAsyncAnimTest returns a Promise that is resolved when the
+    // test is finished so we can chain them together
+    return tests.reduce(function (sequence, test) {
+      return sequence.then(function () {
+        return runAsyncAnimTest(test, aOnAbort);
+      });
+    }, Promise.resolve() /* the start of the sequence */);
+  };
+
+  // Takes a generator function that represents a test case. Each point in the
+  // test case that waits asynchronously for some result yields a Promise that
+  // is resolved when the asynchronous action has completed. By chaining these
+  // intermediate results together we run the test to completion.
+  //
+  // This method itself returns a Promise that is resolved when the generator
+  // function has completed.
+  //
+  // This arrangement is based on add_task() which is currently only available
+  // in mochitest-chrome (bug 872229). If add_task becomes available in
+  // mochitest-plain, we can remove this function and use add_task instead.
+  function runAsyncAnimTest(aTestFunc, aOnAbort) {
+    var generator;
+
+    function step(arg) {
+      var next;
+      try {
+        next = generator.next(arg);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+      if (next.done) {
+        return Promise.resolve(next.value);
+      }
+      return Promise.resolve(next.value).then(step, function (err) {
+        throw err;
+      });
+    }
+
+    // Put refresh driver under test control
+    SpecialPowers.DOMWindowUtils.advanceTimeAndRefresh(0);
+
+    // Run test
+    var promise = aTestFunc();
+    if (!promise.then) {
+      generator = promise;
+      promise = step();
+    }
+    return promise
+      .catch(function (err) {
+        ok(false, err.message);
+        if (typeof aOnAbort == "function") {
+          aOnAbort();
+        }
+      })
+      .then(function () {
+        // Restore clock
+        SpecialPowers.DOMWindowUtils.restoreNormalRefresh();
+      });
+  }
+})();
+
+//----------------------------------------------------------------------
+//
+// Helper functions for testing animated values on the compositor
+//
+//----------------------------------------------------------------------
+
+const RunningOn = {
+  MainThread: 0,
+  Compositor: 1,
+  Either: 2,
+  TodoMainThread: 3,
+  TodoCompositor: 4,
+};
+
+const ExpectComparisonTo = {
+  Pass: 1,
+  Fail: 2,
+};
+
+(function () {
+  window.omta_todo_is = function (
+    elem,
+    property,
+    expected,
+    runningOn,
+    desc,
+    pseudo
+  ) {
+    return omta_is_approx(
+      elem,
+      property,
+      expected,
+      0,
+      runningOn,
+      desc,
+      ExpectComparisonTo.Fail,
+      pseudo
+    );
+  };
+
+  window.omta_is = function (
+    elem,
+    property,
+    expected,
+    runningOn,
+    desc,
+    pseudo
+  ) {
+    return omta_is_approx(
+      elem,
+      property,
+      expected,
+      0,
+      runningOn,
+      desc,
+      ExpectComparisonTo.Pass,
+      pseudo
+    );
+  };
+
+  // Many callers of this method will pass 'undefined' for
+  // expectedComparisonResult.
+  window.omta_is_approx = function (
+    elem,
+    property,
+    expected,
+    tolerance,
+    runningOn,
+    desc,
+    expectedComparisonResult,
+    pseudo
+  ) {
+    // Check input
+    // FIXME: Auto generate this array.
+    const omtaProperties = [
+      "transform",
+      "translate",
+      "rotate",
+      "scale",
+      "offset-path",
+      "offset-distance",
+      "offset-rotate",
+      "offset-anchor",
+      "opacity",
+      "background-color",
+    ];
+    if (!omtaProperties.includes(property)) {
+      ok(false, property + " is not an OMTA property");
+      return;
+    }
+    var normalize;
+    var compare;
+    var normalizedToString = JSON.stringify;
+    switch (property) {
+      case "offset-path":
+      case "offset-distance":
+      case "offset-rotate":
+      case "offset-anchor":
+      case "translate":
+      case "rotate":
+      case "scale":
+        if (runningOn == RunningOn.MainThread) {
+          normalize = value => value;
+          compare = function (a, b, error) {
+            return a == b;
+          };
+          break;
+        }
+      // fall through
+      case "transform":
+        normalize = convertTo3dMatrix;
+        compare = matricesRoughlyEqual;
+        normalizedToString = convert3dMatrixToString;
+        break;
+      case "opacity":
+        normalize = parseFloat;
+        compare = function (a, b, error) {
+          return Math.abs(a - b) <= error;
+        };
+        break;
+      default:
+        normalize = value => value;
+        compare = function (a, b, error) {
+          return a == b;
+        };
+        break;
+    }
+
+    if (!!expected.compositorValue) {
+      const originalNormalize = normalize;
+      normalize = value =>
+        !!value.compositorValue
+          ? originalNormalize(value.compositorValue)
+          : originalNormalize(value);
+    }
+
+    // Get actual values
+    var compositorStr = SpecialPowers.DOMWindowUtils.getOMTAStyle(
+      elem,
+      property,
+      pseudo
+    );
+    var computedStr = window.getComputedStyle(elem, pseudo)[property];
+
+    // Prepare expected value
+    var expectedValue = normalize(expected);
+    if (expectedValue === null) {
+      ok(
+        false,
+        desc +
+          ": test author should provide a valid 'expected' value" +
+          " - got " +
+          expected.toString()
+      );
+      return;
+    }
+
+    // Check expected value appears in the right place
+    var actualStr;
+    switch (runningOn) {
+      case RunningOn.Either:
+        runningOn =
+          compositorStr !== "" ? RunningOn.Compositor : RunningOn.MainThread;
+        actualStr = compositorStr !== "" ? compositorStr : computedStr;
+        break;
+
+      case RunningOn.Compositor:
+        if (compositorStr === "") {
+          ok(false, desc + ": should be animating on compositor");
+          return;
+        }
+        actualStr = compositorStr;
+        break;
+
+      case RunningOn.TodoMainThread:
+        todo(
+          compositorStr === "",
+          desc + ": should NOT be animating on compositor"
+        );
+        actualStr = compositorStr === "" ? computedStr : compositorStr;
+        break;
+
+      case RunningOn.TodoCompositor:
+        todo(
+          compositorStr !== "",
+          desc + ": should be animating on compositor"
+        );
+        actualStr = compositorStr !== "" ? computedStr : compositorStr;
+        break;
+
+      default:
+        if (compositorStr !== "") {
+          ok(false, desc + ": should NOT be animating on compositor");
+          return;
+        }
+        actualStr = computedStr;
+        break;
+    }
+
+    var okOrTodo =
+      expectedComparisonResult == ExpectComparisonTo.Fail ? todo : ok;
+
+    // Compare animated value with expected
+    var actualValue = normalize(actualStr);
+    // Note: the actualStr should be empty string when using todoCompositor, so
+    // actualValue is null in this case. However, compare() should handle null
+    // well.
+    okOrTodo(
+      compare(expectedValue, actualValue, tolerance),
+      desc +
+        " - got " +
+        actualStr +
+        ", expected " +
+        normalizedToString(expectedValue)
+    );
+
+    // For transform-like properties, if we have multiple transform-like
+    // properties, the OMTA value and getComputedStyle() must be different,
+    // so use this flag to skip the following tests.
+    // FIXME: Putting this property on the expected value is a little bit odd.
+    // It's not really a product of the expected value, but rather the kind of
+    // test we're running. That said, the omta_is, omta_todo_is etc. methods are
+    // already pretty complex and adding another parameter would probably
+    // complicate things too much so this is fine for now. If we extend these
+    // functions any more, though, we should probably reconsider this API.
+    if (expected.usesMultipleProperties) {
+      return;
+    }
+
+    if (typeof expected.computed !== "undefined") {
+      // For some tests we specify a separate computed value for comparing
+      // with getComputedStyle.
+      //
+      // In particular, we do this for the individual transform functions since
+      // the form returned from getComputedStyle() reflects the individual
+      // properties (e.g. 'translate: 100px') while the form we read back from
+      // the compositor represents the combined result of all the transform
+      // properties as a single transform matrix (e.g. [0, 0, 0, 0, 100, 0]).
+      //
+      // Despite the fact that we can't directly compare the OMTA value against
+      // the getComputedStyle value in this case, it is still worth checking the
+      // result of getComputedStyle since it will help to alert us if some
+      // discrepancy arises between the way we calculate values on the main
+      // thread and compositor.
+      okOrTodo(
+        computedStr == expected.computed,
+        desc + ": Computed style should be equal to " + expected.computed
+      );
+    } else if (actualStr === compositorStr) {
+      // For compositor animations do an additional check that they match
+      // the value calculated on the main thread
+      var computedValue = normalize(computedStr);
+      if (computedValue === null) {
+        ok(
+          false,
+          desc +
+            ": test framework should parse computed style" +
+            " - got " +
+            computedStr
+        );
+        return;
+      }
+      okOrTodo(
+        compare(computedValue, actualValue, 0.0),
+        desc +
+          ": OMTA style and computed style should be equal" +
+          " - OMTA " +
+          actualStr +
+          ", computed " +
+          computedStr
+      );
+    }
+  };
+
+  window.matricesRoughlyEqual = function (a, b, tolerance) {
+    // Error handle if a or b is invalid.
+    if (!a || !b) {
+      return false;
+    }
+
+    tolerance = tolerance || 0.00011;
+    for (var i = 0; i < 4; i++) {
+      for (var j = 0; j < 4; j++) {
+        var diff = Math.abs(a[i][j] - b[i][j]);
+        if (diff > tolerance || isNaN(diff)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+
+  // Converts something representing an transform into a 3d matrix in
+  // column-major order.
+  // The following are supported:
+  //  "matrix(...)"
+  //  "matrix3d(...)"
+  //  [ 1, 0, 0, ... ]
+  //  { a: 1, ty: 23 } etc.
+  window.convertTo3dMatrix = function (matrixLike) {
+    if (typeof matrixLike == "string") {
+      return convertStringTo3dMatrix(matrixLike);
+    } else if (Array.isArray(matrixLike)) {
+      return convertArrayTo3dMatrix(matrixLike);
+    } else if (typeof matrixLike == "object") {
+      return convertObjectTo3dMatrix(matrixLike);
+    }
+    return null;
+  };
+
+  // In future most of these methods should be able to be replaced
+  // with DOMMatrix
+  window.isInvertible = function (matrix) {
+    return getDeterminant(matrix) != 0;
+  };
+
+  // Converts strings of the format "matrix(...)" and "matrix3d(...)" to a 3d
+  // matrix
+  function convertStringTo3dMatrix(str) {
+    if (str == "none") {
+      return convertArrayTo3dMatrix([1, 0, 0, 1, 0, 0]);
+    }
+    var result = str.match("^matrix(3d)?\\(");
+    if (result === null) {
+      return null;
+    }
+
+    return convertArrayTo3dMatrix(
+      str
+        .substring(result[0].length, str.length - 1)
+        .split(",")
+        .map(function (component) {
+          return Number(component);
+        })
+    );
+  }
+
+  // Takes an array of numbers of length 6 (2d matrix) or 16 (3d matrix)
+  // representing a matrix specified in column-major order and returns a 3d
+  // matrix represented as an array of arrays
+  function convertArrayTo3dMatrix(array) {
+    if (array.length == 6) {
+      return convertObjectTo3dMatrix({
+        a: array[0],
+        b: array[1],
+        c: array[2],
+        d: array[3],
+        e: array[4],
+        f: array[5],
+      });
+    } else if (array.length == 16) {
+      return [
+        array.slice(0, 4),
+        array.slice(4, 8),
+        array.slice(8, 12),
+        array.slice(12, 16),
+      ];
+    }
+    return null;
+  }
+
+  // Return the first defined value in args.
+  function defined(...args) {
+    return args.find(arg => typeof arg !== "undefined");
+  }
+
+  // Takes an object of the form { a: 1.1, e: 23 } and builds up a 3d matrix
+  // with unspecified values filled in with identity values.
+  function convertObjectTo3dMatrix(obj) {
+    return [
+      [
+        defined(obj.a, obj.sx, obj.m11, 1),
+        obj.b || obj.m12 || 0,
+        obj.m13 || 0,
+        obj.m14 || 0,
+      ],
+      [
+        obj.c || obj.m21 || 0,
+        defined(obj.d, obj.sy, obj.m22, 1),
+        obj.m23 || 0,
+        obj.m24 || 0,
+      ],
+      [obj.m31 || 0, obj.m32 || 0, defined(obj.sz, obj.m33, 1), obj.m34 || 0],
+      [
+        obj.e || obj.tx || obj.m41 || 0,
+        obj.f || obj.ty || obj.m42 || 0,
+        obj.tz || obj.m43 || 0,
+        defined(obj.m44, 1),
+      ],
+    ];
+  }
+
+  function convert3dMatrixToString(matrix) {
+    if (is2d(matrix)) {
+      return (
+        "matrix(" +
+        [
+          matrix[0][0],
+          matrix[0][1],
+          matrix[1][0],
+          matrix[1][1],
+          matrix[3][0],
+          matrix[3][1],
+        ].join(", ") +
+        ")"
+      );
+    }
+    return (
+      "matrix3d(" +
+      matrix
+        .reduce(function (outer, inner) {
+          return outer.concat(inner);
+        })
+        .join(", ") +
+      ")"
+    );
+  }
+
+  function is2d(matrix) {
+    return (
+      matrix[0][2] === 0 &&
+      matrix[0][3] === 0 &&
+      matrix[1][2] === 0 &&
+      matrix[1][3] === 0 &&
+      matrix[2][0] === 0 &&
+      matrix[2][1] === 0 &&
+      matrix[2][2] === 1 &&
+      matrix[2][3] === 0 &&
+      matrix[3][2] === 0 &&
+      matrix[3][3] === 1
+    );
+  }
+
+  function getDeterminant(matrix) {
+    if (is2d(matrix)) {
+      return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+    }
+
+    return (
+      matrix[0][3] * matrix[1][2] * matrix[2][1] * matrix[3][0] -
+      matrix[0][2] * matrix[1][3] * matrix[2][1] * matrix[3][0] -
+      matrix[0][3] * matrix[1][1] * matrix[2][2] * matrix[3][0] +
+      matrix[0][1] * matrix[1][3] * matrix[2][2] * matrix[3][0] +
+      matrix[0][2] * matrix[1][1] * matrix[2][3] * matrix[3][0] -
+      matrix[0][1] * matrix[1][2] * matrix[2][3] * matrix[3][0] -
+      matrix[0][3] * matrix[1][2] * matrix[2][0] * matrix[3][1] +
+      matrix[0][2] * matrix[1][3] * matrix[2][0] * matrix[3][1] +
+      matrix[0][3] * matrix[1][0] * matrix[2][2] * matrix[3][1] -
+      matrix[0][0] * matrix[1][3] * matrix[2][2] * matrix[3][1] -
+      matrix[0][2] * matrix[1][0] * matrix[2][3] * matrix[3][1] +
+      matrix[0][0] * matrix[1][2] * matrix[2][3] * matrix[3][1] +
+      matrix[0][3] * matrix[1][1] * matrix[2][0] * matrix[3][2] -
+      matrix[0][1] * matrix[1][3] * matrix[2][0] * matrix[3][2] -
+      matrix[0][3] * matrix[1][0] * matrix[2][1] * matrix[3][2] +
+      matrix[0][0] * matrix[1][3] * matrix[2][1] * matrix[3][2] +
+      matrix[0][1] * matrix[1][0] * matrix[2][3] * matrix[3][2] -
+      matrix[0][0] * matrix[1][1] * matrix[2][3] * matrix[3][2] -
+      matrix[0][2] * matrix[1][1] * matrix[2][0] * matrix[3][3] +
+      matrix[0][1] * matrix[1][2] * matrix[2][0] * matrix[3][3] +
+      matrix[0][2] * matrix[1][0] * matrix[2][1] * matrix[3][3] -
+      matrix[0][0] * matrix[1][2] * matrix[2][1] * matrix[3][3] -
+      matrix[0][1] * matrix[1][0] * matrix[2][2] * matrix[3][3] +
+      matrix[0][0] * matrix[1][1] * matrix[2][2] * matrix[3][3]
+    );
+  }
+})();
+
+//----------------------------------------------------------------------
+//
+// Promise wrappers for paint_listener.js
+//
+//----------------------------------------------------------------------
+
+// Returns a Promise that resolves once all paints have completed
+function waitForPaints() {
+  return new Promise(function (resolve, reject) {
+    waitForAllPaints(resolve);
+  });
+}
+
+// As with waitForPaints but also flushes pending style changes before waiting
+function waitForPaintsFlushed() {
+  return new Promise(function (resolve, reject) {
+    waitForAllPaintsFlushed(resolve);
+  });
+}
+
+function waitForVisitedLinkColoring(visitedLink, waitProperty, waitValue) {
+  function checkLink(resolve) {
+    if (
+      SpecialPowers.DOMWindowUtils.getVisitedDependentComputedStyle(
+        visitedLink,
+        "",
+        waitProperty
+      ) == waitValue
+    ) {
+      // Our link has been styled as visited.  Resolve.
+      resolve(true);
+    } else {
+      // Our link is not yet styled as visited.  Poll for completion.
+      setTimeout(checkLink, 0, resolve);
+    }
+  }
+  return new Promise(function (resolve, reject) {
+    checkLink(resolve);
+  });
+}