1 files changed, 87 insertions, 0 deletions
diff --git a/dom/base/test/fullscreen/file_fullscreen-utils.js b/dom/base/test/fullscreen/file_fullscreen-utils.js
new file mode 100644
index 0000000000..b4779da4de
--- /dev/null
+++ b/dom/base/test/fullscreen/file_fullscreen-utils.js
@@ -0,0 +1,87 @@
+// Keep track of how many fullscreenChange enters we've received, so that
+// we can balance them with the number of exits we receive. We reset this
+// to 0 when we load a test.
+var fullscreenChangeEnters = 0;
+
+addLoadEvent(function () {
+  info(`Resetting fullscreen enter count.`);
+  fullscreenChangeEnters = 0;
+});
+
+// This can be used to force a certain value for fullscreenChangeEnters
+// to handle unusual conditions -- such as exiting multiple levels of
+// fullscreen forcibly.
+function setFullscreenChangeEnters(enters) {
+  info(`Setting fullscreen enter count to ${enters}.`);
+  fullscreenChangeEnters = enters;
+}
+
+// Returns true if the window believes it is in fullscreen. This may be true even
+// before an asynchronous fullscreen transition is complete.
+function inFullscreenMode(win) {
+  return win.document.fullscreenElement;
+}
+
+// Adds a listener that will be called once a fullscreen transition
+// is complete. When type==='enter', callback is called when we've
+// received a fullscreenchange event, and the fullscreen transition is
+// complete. When type==='exit', callback is called when we've
+// received a fullscreenchange event and the window is out of
+// fullscreen. inDoc is the document which the listeners are added on,
+// if absent, the listeners are added to the current document.
+// the current document.
+function addFullscreenChangeContinuation(type, callback, inDoc) {
+  var doc = inDoc || document;
+  var topWin = doc.defaultView.top;
+  function checkCondition() {
+    if (type == "enter") {
+      fullscreenChangeEnters++;
+      return inFullscreenMode(topWin);
+    } else if (type == "exit") {
+      fullscreenChangeEnters--;
+      return fullscreenChangeEnters
+        ? inFullscreenMode(topWin)
+        : !inFullscreenMode(topWin);
+    }
+    throw new Error("'type' must be either 'enter', or 'exit'.");
+  }
+  function onFullscreenChange(event) {
+    doc.removeEventListener("fullscreenchange", onFullscreenChange);
+    ok(checkCondition(), `Should ${type} fullscreen.`);
+    // Delay invocation so other listeners have a chance to respond before
+    // we continue.
+    requestAnimationFrame(() => setTimeout(() => callback(event), 0), 0);
+  }
+  doc.addEventListener("fullscreenchange", onFullscreenChange);
+}
+
+// Calls |callback| when the next fullscreenerror is dispatched to inDoc||document.
+function addFullscreenErrorContinuation(callback, inDoc) {
+  let doc = inDoc || document;
+  let listener = function (event) {
+    doc.removeEventListener("fullscreenerror", listener);
+    // Delay invocation so other listeners have a chance to respond before
+    // we continue.
+    requestAnimationFrame(() => setTimeout(() => callback(event), 0), 0);
+  };
+  doc.addEventListener("fullscreenerror", listener);
+}
+
+// Waits until the window has both the load event and a MozAfterPaint called on
+// it, and then invokes the callback
+function waitForLoadAndPaint(win, callback) {
+  win.addEventListener(
+    "MozAfterPaint",
+    function () {
+      // The load event may have fired before the MozAfterPaint, in which case
+      // listening for it now will hang. Instead we check the readyState to see if
+      // it already fired, and if so, invoke the callback right away.
+      if (win.document.readyState == "complete") {
+        callback();
+      } else {
+        win.addEventListener("load", callback, { once: true });
+      }
+    },
+    { once: true }
+  );
+}