The Tor Browser: comparison layout/style/test/animation_utils.js

comparison: layout/style/test/animation_utils.js

layout/style/test/animation_utils.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:8c52f3f64891
+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);
+}
+// 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.
+function runOMTATest(aTestFunction, aOnSkip) {
+const OMTAPrefKey = "layers.offmainthreadcomposition.async-animations";
+var utils      = SpecialPowers.DOMWindowUtils;
+var expectOMTA = utils.layerManagerRemote &&
+// ^ Off-main thread animation cannot be used if off-main
+// thread composition (OMTC) is not available
+SpecialPowers.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 is working as expected");
+aOnSkip();
+}
+} else {
+todo(isWorking, "OMTA is working");
+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.parentNode.removeChild(div);
+style.parentNode.removeChild(style);
+if (utils.isTestControllingRefreshes) {
+utils.restoreNormalRefresh();
+}
+};
+return waitForDocumentLoad()
+.then(loadPaintListener)
+.then(function() {
+// Put refresh driver under test control and trigger animation
+utils.advanceTimeAndRefresh(0);
+div.style.animation = animationName + " 10s";
+// Trigger style flush
+div.clientTop;
+return waitForPaints();
+}).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 waitForPaints() {
+return new Promise(function(resolve, reject) {
+waitForAllPaintsFlushed(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();
+}
+});
+}
+}