/* 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/. */

/* eslint-env mozilla/frame-script */

const XHTML_NS = "http://www.w3.org/1999/xhtml";

const DEBUG_CONTRACTID = "@mozilla.org/xpcom/debug;1";
const PRINTSETTINGS_CONTRACTID = "@mozilla.org/gfx/printsettings-service;1";
const NS_OBSERVER_SERVICE_CONTRACTID = "@mozilla.org/observer-service;1";
const NS_GFXINFO_CONTRACTID = "@mozilla.org/gfx/info;1";
const IO_SERVICE_CONTRACTID = "@mozilla.org/network/io-service;1";

// "<!--CLEAR-->"
const BLANK_URL_FOR_CLEARING =
  "data:text/html;charset=UTF-8,%3C%21%2D%2DCLEAR%2D%2D%3E";

const { setTimeout, clearTimeout } = ChromeUtils.importESModule(
  "resource://gre/modules/Timer.sys.mjs"
);
const { onSpellCheck } = ChromeUtils.importESModule(
  "resource://reftest/AsyncSpellCheckTestHelper.sys.mjs"
);

// This will load chrome Custom Elements inside chrome documents:
ChromeUtils.importESModule(
  "resource://gre/modules/CustomElementsListener.sys.mjs"
);

var gBrowserIsRemote;
var gHaveCanvasSnapshot = false;
var gCurrentURL;
var gCurrentURLRecordResults;
var gCurrentURLTargetType;
var gCurrentTestType;
var gTimeoutHook = null;
var gFailureTimeout = null;
var gFailureReason;
var gAssertionCount = 0;
var gUpdateCanvasPromiseResolver = null;

var gDebug;
var gVerbose = false;

var gCurrentTestStartTime;
var gClearingForAssertionCheck = false;

const TYPE_LOAD = "load"; // test without a reference (just test that it does
// not assert, crash, hang, or leak)
const TYPE_SCRIPT = "script"; // test contains individual test results
const TYPE_PRINT = "print"; // test and reference will be printed to PDF's and
// compared structurally

// keep this in sync with globals.sys.mjs
const URL_TARGET_TYPE_TEST = 0; // first url
const URL_TARGET_TYPE_REFERENCE = 1; // second url, if any

function webNavigation() {
  return docShell.QueryInterface(Ci.nsIWebNavigation);
}

function webProgress() {
  return docShell
    .QueryInterface(Ci.nsIInterfaceRequestor)
    .getInterface(Ci.nsIWebProgress);
}

function windowUtilsForWindow(w) {
  return w.windowUtils;
}

function windowUtils() {
  return windowUtilsForWindow(content);
}

function IDForEventTarget(event) {
  try {
    return "'" + event.target.getAttribute("id") + "'";
  } catch (ex) {
    return "<unknown>";
  }
}

var progressListener = {
  onStateChange(webprogress, request, flags, status) {
    let uri;
    try {
      request.QueryInterface(Ci.nsIChannel);
      uri = request.originalURI.spec;
    } catch (ex) {
      return;
    }
    const WPL = Ci.nsIWebProgressListener;
    const endFlags =
      WPL.STATE_STOP | WPL.STATE_IS_WINDOW | WPL.STATE_IS_NETWORK;
    if ((flags & endFlags) == endFlags) {
      OnDocumentLoad(uri);
    }
  },
  QueryInterface: ChromeUtils.generateQI([
    "nsIWebProgressListener",
    "nsISupportsWeakReference",
  ]),
};

function OnInitialLoad() {
  removeEventListener("load", OnInitialLoad, true);

  gDebug = Cc[DEBUG_CONTRACTID].getService(Ci.nsIDebug2);
  if (gDebug.isDebugBuild) {
    gAssertionCount = gDebug.assertionCount;
  }
  gVerbose = !!Services.env.get("MOZ_REFTEST_VERBOSE");

  RegisterMessageListeners();

  var initInfo = SendContentReady();
  gBrowserIsRemote = initInfo.remote;

  webProgress().addProgressListener(
    progressListener,
    Ci.nsIWebProgress.NOTIFY_STATE_WINDOW
  );

  LogInfo("Using browser remote=" + gBrowserIsRemote + "\n");
}

function SetFailureTimeout(cb, timeout, uri) {
  var targetTime = Date.now() + timeout;

  var wrapper = function () {
    // Timeouts can fire prematurely in some cases (e.g. in chaos mode). If this
    // happens, set another timeout for the remaining time.
    let remainingMs = targetTime - Date.now();
    if (remainingMs > 0) {
      SetFailureTimeout(cb, remainingMs);
    } else {
      cb();
    }
  };

  // Once OnDocumentLoad is called to handle the 'load' event it will update
  // this error message to reflect what stage of the processing it has reached
  // as it advances to each stage in turn.
  gFailureReason =
    "timed out after " + timeout + " ms waiting for 'load' event for " + uri;
  gFailureTimeout = setTimeout(wrapper, timeout);
}

function StartTestURI(type, uri, uriTargetType, timeout) {
  // The GC is only able to clean up compartments after the CC runs. Since
  // the JS ref tests disable the normal browser chrome and do not otherwise
  // create substatial DOM garbage, the CC tends not to run enough normally.
  windowUtils().runNextCollectorTimer();

  gCurrentTestType = type;
  gCurrentURL = uri;
  gCurrentURLTargetType = uriTargetType;
  gCurrentURLRecordResults = 0;

  gCurrentTestStartTime = Date.now();
  if (gFailureTimeout != null) {
    SendException("program error managing timeouts\n");
  }
  SetFailureTimeout(LoadFailed, timeout, uri);

  LoadURI(gCurrentURL);
}

function setupTextZoom(contentRootElement) {
  if (
    !contentRootElement ||
    !contentRootElement.hasAttribute("reftest-text-zoom")
  ) {
    return;
  }
  docShell.browsingContext.textZoom =
    contentRootElement.getAttribute("reftest-text-zoom");
}

function setupFullZoom(contentRootElement) {
  if (!contentRootElement || !contentRootElement.hasAttribute("reftest-zoom")) {
    return;
  }
  docShell.browsingContext.fullZoom =
    contentRootElement.getAttribute("reftest-zoom");
}

function resetZoomAndTextZoom() {
  docShell.browsingContext.fullZoom = 1.0;
  docShell.browsingContext.textZoom = 1.0;
}

function doPrintMode(contentRootElement) {
  // use getAttribute because className works differently in HTML and SVG
  if (contentRootElement && contentRootElement.hasAttribute("class")) {
    var classList = contentRootElement.getAttribute("class").split(/\s+/);
    if (classList.includes("reftest-print")) {
      SendException("reftest-print is obsolete, use reftest-paged instead");
      return false;
    }
    return classList.includes("reftest-paged");
  }
  return false;
}

function setupPrintMode(contentRootElement) {
  var PSSVC = Cc[PRINTSETTINGS_CONTRACTID].getService(
    Ci.nsIPrintSettingsService
  );
  var ps = PSSVC.createNewPrintSettings();
  ps.paperWidth = 5;
  ps.paperHeight = 3;

  // Override any os-specific unwriteable margins
  ps.unwriteableMarginTop = 0;
  ps.unwriteableMarginLeft = 0;
  ps.unwriteableMarginBottom = 0;
  ps.unwriteableMarginRight = 0;

  ps.headerStrLeft = "";
  ps.headerStrCenter = "";
  ps.headerStrRight = "";
  ps.footerStrLeft = "";
  ps.footerStrCenter = "";
  ps.footerStrRight = "";

  const printBackgrounds = (() => {
    const attr = contentRootElement.getAttribute("reftest-paged-backgrounds");
    return !attr || attr != "false";
  })();
  ps.printBGColors = printBackgrounds;
  ps.printBGImages = printBackgrounds;

  docShell.docViewer.setPageModeForTesting(/* aPageMode */ true, ps);
}

// Message the parent process to ask it to print the current page to a PDF file.
function printToPdf() {
  let currentDoc = content.document;
  let isPrintSelection = false;
  let printRange = "";

  if (currentDoc) {
    let contentRootElement = currentDoc.documentElement;
    printRange = contentRootElement.getAttribute("reftest-print-range") || "";
  }

  if (printRange) {
    if (printRange === "selection") {
      isPrintSelection = true;
    } else if (
      !printRange.split(",").every(range => /^[1-9]\d*-[1-9]\d*$/.test(range))
    ) {
      SendException("invalid value for reftest-print-range");
      return;
    }
  }

  SendStartPrint(isPrintSelection, printRange);
}

function attrOrDefault(element, attr, def) {
  return element.hasAttribute(attr) ? Number(element.getAttribute(attr)) : def;
}

function setupViewport(contentRootElement) {
  if (!contentRootElement) {
    return;
  }

  var sw = attrOrDefault(contentRootElement, "reftest-scrollport-w", 0);
  var sh = attrOrDefault(contentRootElement, "reftest-scrollport-h", 0);
  if (sw !== 0 || sh !== 0) {
    LogInfo("Setting viewport to <w=" + sw + ", h=" + sh + ">");
    windowUtils().setVisualViewportSize(sw, sh);
  }

  var res = attrOrDefault(contentRootElement, "reftest-resolution", 1);
  if (res !== 1) {
    LogInfo("Setting resolution to " + res);
    windowUtils().setResolutionAndScaleTo(res);
  }

  // XXX support viewconfig when needed
}

function setupDisplayport(contentRootElement) {
  let promise = content.windowGlobalChild
    .getActor("ReftestFission")
    .SetupDisplayportRoot();
  return promise.then(
    function (result) {
      for (let errorString of result.errorStrings) {
        LogError(errorString);
      }
      for (let infoString of result.infoStrings) {
        LogInfo(infoString);
      }
    },
    function (reason) {
      LogError("SetupDisplayportRoot returned promise rejected: " + reason);
    }
  );
}

// Returns whether any offsets were updated
function setupAsyncScrollOffsets(options) {
  let currentDoc = content.document;
  let contentRootElement = currentDoc ? currentDoc.documentElement : null;

  if (
    !contentRootElement ||
    !contentRootElement.hasAttribute("reftest-async-scroll")
  ) {
    return Promise.resolve(false);
  }

  let allowFailure = options.allowFailure;
  let promise = content.windowGlobalChild
    .getActor("ReftestFission")
    .sendQuery("SetupAsyncScrollOffsets", { allowFailure });
  return promise.then(
    function (result) {
      for (let errorString of result.errorStrings) {
        LogError(errorString);
      }
      for (let infoString of result.infoStrings) {
        LogInfo(infoString);
      }
      return result.updatedAny;
    },
    function (reason) {
      LogError(
        "SetupAsyncScrollOffsets SendQuery to parent promise rejected: " +
          reason
      );
      return false;
    }
  );
}

function setupAsyncZoom(options) {
  var currentDoc = content.document;
  var contentRootElement = currentDoc ? currentDoc.documentElement : null;

  if (
    !contentRootElement ||
    !contentRootElement.hasAttribute("reftest-async-zoom")
  ) {
    return false;
  }

  var zoom = attrOrDefault(contentRootElement, "reftest-async-zoom", 1);
  if (zoom != 1) {
    try {
      windowUtils().setAsyncZoom(contentRootElement, zoom);
      return true;
    } catch (e) {
      if (!options.allowFailure) {
        throw e;
      }
    }
  }
  return false;
}

function resetDisplayportAndViewport() {
  // XXX currently the displayport configuration lives on the
  // presshell and so is "reset" on nav when we get a new presshell.
}

function shouldWaitForPendingPaints() {
  // if gHaveCanvasSnapshot is false, we're not taking snapshots so
  // there is no need to wait for pending paints to be flushed.
  return gHaveCanvasSnapshot && windowUtils().isMozAfterPaintPending;
}

function shouldWaitForReftestWaitRemoval(contentRootElement) {
  // use getAttribute because className works differently in HTML and SVG
  return (
    contentRootElement &&
    contentRootElement.hasAttribute("class") &&
    contentRootElement
      .getAttribute("class")
      .split(/\s+/)
      .includes("reftest-wait")
  );
}

function shouldSnapshotWholePage(contentRootElement) {
  // use getAttribute because className works differently in HTML and SVG
  return (
    contentRootElement &&
    contentRootElement.hasAttribute("class") &&
    contentRootElement
      .getAttribute("class")
      .split(/\s+/)
      .includes("reftest-snapshot-all")
  );
}

function shouldNotFlush(contentRootElement) {
  // use getAttribute because className works differently in HTML and SVG
  return (
    contentRootElement &&
    contentRootElement.hasAttribute("class") &&
    contentRootElement
      .getAttribute("class")
      .split(/\s+/)
      .includes("reftest-no-flush")
  );
}

function getNoPaintElements(contentRootElement) {
  return contentRootElement.getElementsByClassName("reftest-no-paint");
}
function getNoDisplayListElements(contentRootElement) {
  return contentRootElement.getElementsByClassName("reftest-no-display-list");
}
function getDisplayListElements(contentRootElement) {
  return contentRootElement.getElementsByClassName("reftest-display-list");
}

function getOpaqueLayerElements(contentRootElement) {
  return contentRootElement.getElementsByClassName("reftest-opaque-layer");
}

function getAssignedLayerMap(contentRootElement) {
  var layerNameToElementsMap = {};
  var elements = contentRootElement.querySelectorAll(
    "[reftest-assigned-layer]"
  );
  for (var i = 0; i < elements.length; ++i) {
    var element = elements[i];
    var layerName = element.getAttribute("reftest-assigned-layer");
    if (!(layerName in layerNameToElementsMap)) {
      layerNameToElementsMap[layerName] = [];
    }
    layerNameToElementsMap[layerName].push(element);
  }
  return layerNameToElementsMap;
}

const FlushMode = {
  ALL: 0,
  IGNORE_THROTTLED_ANIMATIONS: 1,
};

// Initial state. When the document has loaded and all MozAfterPaint events and
// all explicit paint waits are flushed, we can fire the MozReftestInvalidate
// event and move to the next state.
const STATE_WAITING_TO_FIRE_INVALIDATE_EVENT = 0;
// When reftest-wait has been removed from the root element, we can move to the
// next state.
const STATE_WAITING_FOR_REFTEST_WAIT_REMOVAL = 1;
// When spell checking is done on all spell-checked elements, we can move to the
// next state.
const STATE_WAITING_FOR_SPELL_CHECKS = 2;
// When any pending compositor-side repaint requests have been flushed, we can
// move to the next state.
const STATE_WAITING_FOR_APZ_FLUSH = 3;
// When all MozAfterPaint events and all explicit paint waits are flushed, we're
// done and can move to the COMPLETED state.
const STATE_WAITING_TO_FINISH = 4;
const STATE_COMPLETED = 5;

async function FlushRendering(aFlushMode) {
  let browsingContext = content.docShell.browsingContext;
  let ignoreThrottledAnimations =
    aFlushMode === FlushMode.IGNORE_THROTTLED_ANIMATIONS;
  // Ensure the refresh driver ticks at least once, this ensures some
  // preference changes take effect.
  let needsAnimationFrame = IsSnapshottableTestType();
  try {
    let result = await content.windowGlobalChild
      .getActor("ReftestFission")
      .sendQuery("FlushRendering", {
        browsingContext,
        ignoreThrottledAnimations,
        needsAnimationFrame,
      });
    for (let errorString of result.errorStrings) {
      LogError(errorString);
    }
    for (let warningString of result.warningStrings) {
      LogWarning(warningString);
    }
    for (let infoString of result.infoStrings) {
      LogInfo(infoString);
    }
  } catch (reason) {
    // We expect actors to go away causing sendQuery's to fail, so
    // just note it.
    LogInfo("FlushRendering sendQuery to parent rejected: " + reason);
  }
}

function WaitForTestEnd(
  contentRootElement,
  inPrintMode,
  spellCheckedElements,
  forURL
) {
  // WaitForTestEnd works via the MakeProgress function below. It is responsible for
  // moving through the states listed above and calling FlushRendering. We also listen
  // for a number of events, the most important of which is the AfterPaintListener,
  // which is responsible for updating the canvas after paints. In a fission world
  // FlushRendering and updating the canvas must necessarily be async operations.
  // During these async operations we want to wait for them to finish and we don't
  // want to try to do anything else (what would we even want to do while only some of
  // the processes involved have flushed layout or updated their layer trees?). So
  // we call OperationInProgress whenever we are about to go back to the event loop
  // during one of these calls, and OperationCompleted when it finishes. This prevents
  // anything else from running while we wait and getting us into a confused state. We
  // then record anything that happens while we are waiting to make sure that the
  // right actions are triggered. The possible actions are basically calling
  // MakeProgress from a setTimeout, and updating the canvas for an after paint event.
  // The after paint listener just stashes the rects and we update them after a
  // completed MakeProgress call. This is handled by
  // HandlePendingTasksAfterMakeProgress, which also waits for any pending after paint
  // events. The general sequence of events is:
  //   - MakeProgress
  //   - HandlePendingTasksAfterMakeProgress
  //     - wait for after paint event if one is pending
  //     - update canvas for after paint events we have received
  //   - MakeProgress
  //   etc

  function CheckForLivenessOfContentRootElement() {
    if (contentRootElement && Cu.isDeadWrapper(contentRootElement)) {
      contentRootElement = null;
    }
  }

  var setTimeoutCallMakeProgressWhenComplete = false;

  var operationInProgress = false;
  function OperationInProgress() {
    if (operationInProgress) {
      LogWarning("Nesting atomic operations?");
    }
    operationInProgress = true;
  }
  function OperationCompleted() {
    if (!operationInProgress) {
      LogWarning("Mismatched OperationInProgress/OperationCompleted calls?");
    }
    operationInProgress = false;
    if (setTimeoutCallMakeProgressWhenComplete) {
      setTimeoutCallMakeProgressWhenComplete = false;
      setTimeout(CallMakeProgress, 0);
    }
  }
  function AssertNoOperationInProgress() {
    if (operationInProgress) {
      LogWarning("AssertNoOperationInProgress but operationInProgress");
    }
  }

  var updateCanvasPending = false;
  var updateCanvasRects = [];

  var currentDoc = content.document;
  var state = STATE_WAITING_TO_FIRE_INVALIDATE_EVENT;

  var setTimeoutMakeProgressPending = false;

  function CallSetTimeoutMakeProgress() {
    if (setTimeoutMakeProgressPending) {
      return;
    }
    setTimeoutMakeProgressPending = true;
    setTimeout(CallMakeProgress, 0);
  }

  // This should only ever be called from a timeout.
  function CallMakeProgress() {
    if (operationInProgress) {
      setTimeoutCallMakeProgressWhenComplete = true;
      return;
    }
    setTimeoutMakeProgressPending = false;
    MakeProgress();
  }

  var waitingForAnAfterPaint = false;

  // Updates the canvas if there are pending updates for it. Checks if we
  // need to call MakeProgress.
  function HandlePendingTasksAfterMakeProgress() {
    AssertNoOperationInProgress();

    if (
      (state == STATE_WAITING_TO_FIRE_INVALIDATE_EVENT ||
        state == STATE_WAITING_TO_FINISH) &&
      shouldWaitForPendingPaints()
    ) {
      LogInfo(
        "HandlePendingTasksAfterMakeProgress waiting for a MozAfterPaint"
      );
      // We are in a state where we wait for MozAfterPaint to clear and a
      // MozAfterPaint event is pending, give it a chance to fire, but don't
      // let anything else run.
      waitingForAnAfterPaint = true;
      OperationInProgress();
      return;
    }

    if (updateCanvasPending) {
      LogInfo("HandlePendingTasksAfterMakeProgress updating canvas");
      updateCanvasPending = false;
      let rects = updateCanvasRects;
      updateCanvasRects = [];
      OperationInProgress();
      CheckForLivenessOfContentRootElement();
      let promise = SendUpdateCanvasForEvent(forURL, rects, contentRootElement);
      promise.then(function () {
        OperationCompleted();
        // After paint events are fired immediately after a paint (one
        // of the things that can call us). Don't confuse ourselves by
        // firing synchronously if we triggered the paint ourselves.
        CallSetTimeoutMakeProgress();
      });
    }
  }

  // true if rectA contains rectB
  function Contains(rectA, rectB) {
    return (
      rectA.left <= rectB.left &&
      rectB.right <= rectA.right &&
      rectA.top <= rectB.top &&
      rectB.bottom <= rectA.bottom
    );
  }
  // true if some rect in rectList contains rect
  function ContainedIn(rectList, rect) {
    for (let i = 0; i < rectList.length; ++i) {
      if (Contains(rectList[i], rect)) {
        return true;
      }
    }
    return false;
  }

  function AfterPaintListener(event) {
    LogInfo("AfterPaintListener in " + event.target.document.location.href);
    if (event.target.document != currentDoc) {
      // ignore paint events for subframes or old documents in the window.
      // Invalidation in subframes will cause invalidation in the toplevel document anyway.
      return;
    }

    updateCanvasPending = true;
    for (let r of event.clientRects) {
      if (ContainedIn(updateCanvasRects, r)) {
        continue;
      }

      // Copy the rect; it's content and we are chrome, which means if the
      // document goes away (and it can in some crashtests) our reference
      // to it will be turned into a dead wrapper that we can't acccess.
      updateCanvasRects.push({
        left: r.left,
        top: r.top,
        right: r.right,
        bottom: r.bottom,
      });
    }

    if (waitingForAnAfterPaint) {
      waitingForAnAfterPaint = false;
      OperationCompleted();
    }

    if (!operationInProgress) {
      HandlePendingTasksAfterMakeProgress();
    }
    // Otherwise we know that eventually after the operation finishes we
    // will get a MakeProgress and/or HandlePendingTasksAfterMakeProgress
    // call, so we don't need to do anything.
  }

  function FromChildAfterPaintListener(event) {
    LogInfo(
      "FromChildAfterPaintListener from " + event.detail.originalTargetUri
    );

    updateCanvasPending = true;
    for (let r of event.detail.rects) {
      if (ContainedIn(updateCanvasRects, r)) {
        continue;
      }

      // Copy the rect; it's content and we are chrome, which means if the
      // document goes away (and it can in some crashtests) our reference
      // to it will be turned into a dead wrapper that we can't acccess.
      updateCanvasRects.push({
        left: r.left,
        top: r.top,
        right: r.right,
        bottom: r.bottom,
      });
    }

    if (!operationInProgress) {
      HandlePendingTasksAfterMakeProgress();
    }
    // Otherwise we know that eventually after the operation finishes we
    // will get a MakeProgress and/or HandlePendingTasksAfterMakeProgress
    // call, so we don't need to do anything.
  }

  let attrModifiedObserver;
  function AttrModifiedListener() {
    LogInfo("AttrModifiedListener fired");
    // Wait for the next return-to-event-loop before continuing --- for
    // example, the attribute may have been modified in an subdocument's
    // load event handler, in which case we need load event processing
    // to complete and unsuppress painting before we check isMozAfterPaintPending.
    CallSetTimeoutMakeProgress();
  }

  function RemoveListeners() {
    // OK, we can end the test now.
    removeEventListener("MozAfterPaint", AfterPaintListener, false);
    removeEventListener(
      "Reftest:MozAfterPaintFromChild",
      FromChildAfterPaintListener,
      false
    );
    CheckForLivenessOfContentRootElement();
    if (attrModifiedObserver) {
      if (!Cu.isDeadWrapper(attrModifiedObserver)) {
        attrModifiedObserver.disconnect();
      }
      attrModifiedObserver = null;
    }
    gTimeoutHook = null;
    // Make sure we're in the COMPLETED state just in case
    // (this may be called via the test-timeout hook)
    state = STATE_COMPLETED;
  }

  // Everything that could cause shouldWaitForXXX() to
  // change from returning true to returning false is monitored via some kind
  // of event listener which eventually calls this function.
  function MakeProgress() {
    if (state >= STATE_COMPLETED) {
      LogInfo("MakeProgress: STATE_COMPLETED");
      return;
    }

    LogInfo("MakeProgress");

    // We don't need to flush styles any more when we are in the state
    // after reftest-wait has removed.
    OperationInProgress();
    let promise = Promise.resolve(undefined);
    if (state != STATE_WAITING_TO_FINISH) {
      // If we are waiting for the MozReftestInvalidate event we don't want
      // to flush throttled animations. Flushing throttled animations can
      // continue to cause new MozAfterPaint events even when all the
      // rendering we're concerned about should have ceased. Since
      // MozReftestInvalidate won't be sent until we finish waiting for all
      // MozAfterPaint events, we should avoid flushing throttled animations
      // here or else we'll never leave this state.
      let flushMode =
        state === STATE_WAITING_TO_FIRE_INVALIDATE_EVENT
          ? FlushMode.IGNORE_THROTTLED_ANIMATIONS
          : FlushMode.ALL;
      promise = FlushRendering(flushMode);
    }
    promise.then(function () {
      OperationCompleted();
      MakeProgress2();
      // If there is an operation in progress then we know there will be
      // a MakeProgress call is will happen after it finishes.
      if (!operationInProgress) {
        HandlePendingTasksAfterMakeProgress();
      }
    });
  }

  // eslint-disable-next-line complexity
  function MakeProgress2() {
    switch (state) {
      case STATE_WAITING_TO_FIRE_INVALIDATE_EVENT: {
        LogInfo("MakeProgress: STATE_WAITING_TO_FIRE_INVALIDATE_EVENT");
        if (shouldWaitForPendingPaints() || updateCanvasPending) {
          gFailureReason =
            "timed out waiting for pending paint count to reach zero";
          if (shouldWaitForPendingPaints()) {
            gFailureReason += " (waiting for MozAfterPaint)";
            LogInfo("MakeProgress: waiting for MozAfterPaint");
          }
          if (updateCanvasPending) {
            gFailureReason += " (waiting for updateCanvasPending)";
            LogInfo("MakeProgress: waiting for updateCanvasPending");
          }
          return;
        }

        state = STATE_WAITING_FOR_REFTEST_WAIT_REMOVAL;
        CheckForLivenessOfContentRootElement();
        var hasReftestWait =
          shouldWaitForReftestWaitRemoval(contentRootElement);
        // Notify the test document that now is a good time to test some invalidation
        LogInfo("MakeProgress: dispatching MozReftestInvalidate");
        if (contentRootElement) {
          let elements = getNoPaintElements(contentRootElement);
          for (let i = 0; i < elements.length; ++i) {
            windowUtils().checkAndClearPaintedState(elements[i]);
          }
          elements = getNoDisplayListElements(contentRootElement);
          for (let i = 0; i < elements.length; ++i) {
            windowUtils().checkAndClearDisplayListState(elements[i]);
          }
          elements = getDisplayListElements(contentRootElement);
          for (let i = 0; i < elements.length; ++i) {
            windowUtils().checkAndClearDisplayListState(elements[i]);
          }
          var notification = content.document.createEvent("Events");
          notification.initEvent("MozReftestInvalidate", true, false);
          contentRootElement.dispatchEvent(notification);
        } else {
          LogInfo(
            "MakeProgress: couldn't send MozReftestInvalidate event because content root element does not exist"
          );
        }

        CheckForLivenessOfContentRootElement();
        if (!inPrintMode && doPrintMode(contentRootElement)) {
          LogInfo("MakeProgress: setting up print mode");
          setupPrintMode(contentRootElement);
        }

        CheckForLivenessOfContentRootElement();
        if (
          hasReftestWait &&
          !shouldWaitForReftestWaitRemoval(contentRootElement)
        ) {
          // MozReftestInvalidate handler removed reftest-wait.
          // We expect something to have been invalidated...
          OperationInProgress();
          let promise = FlushRendering(FlushMode.ALL);
          promise.then(function () {
            OperationCompleted();
            if (!updateCanvasPending && !shouldWaitForPendingPaints()) {
              LogWarning("MozInvalidateEvent didn't invalidate");
            }
            MakeProgress();
          });
          return;
        }
        // Try next state
        MakeProgress();
        return;
      }

      case STATE_WAITING_FOR_REFTEST_WAIT_REMOVAL:
        LogInfo("MakeProgress: STATE_WAITING_FOR_REFTEST_WAIT_REMOVAL");
        CheckForLivenessOfContentRootElement();
        if (shouldWaitForReftestWaitRemoval(contentRootElement)) {
          gFailureReason = "timed out waiting for reftest-wait to be removed";
          LogInfo("MakeProgress: waiting for reftest-wait to be removed");
          return;
        }

        if (shouldNotFlush(contentRootElement)) {
          // If reftest-no-flush is specified, we need to set
          // updateCanvasPending explicitly to take the latest snapshot
          // since animation changes on the compositor thread don't invoke
          // any MozAfterPaint events at all.
          // NOTE: We don't add any rects to updateCanvasRects here since
          // SendUpdateCanvasForEvent() will handle this case properly
          // without any rects.
          updateCanvasPending = true;
        }
        // Try next state
        state = STATE_WAITING_FOR_SPELL_CHECKS;
        MakeProgress();
        return;

      case STATE_WAITING_FOR_SPELL_CHECKS:
        LogInfo("MakeProgress: STATE_WAITING_FOR_SPELL_CHECKS");
        if (numPendingSpellChecks) {
          gFailureReason = "timed out waiting for spell checks to end";
          LogInfo("MakeProgress: waiting for spell checks to end");
          return;
        }

        state = STATE_WAITING_FOR_APZ_FLUSH;
        LogInfo("MakeProgress: STATE_WAITING_FOR_APZ_FLUSH");
        gFailureReason = "timed out waiting for APZ flush to complete";

        var flushWaiter = function (aSubject, aTopic, aData) {
          if (aTopic) {
            LogInfo("MakeProgress: apz-repaints-flushed fired");
          }
          Services.obs.removeObserver(flushWaiter, "apz-repaints-flushed");
          state = STATE_WAITING_TO_FINISH;
          if (operationInProgress) {
            CallSetTimeoutMakeProgress();
          } else {
            MakeProgress();
          }
        };
        Services.obs.addObserver(flushWaiter, "apz-repaints-flushed");

        var willSnapshot = IsSnapshottableTestType();
        CheckForLivenessOfContentRootElement();
        var noFlush = !shouldNotFlush(contentRootElement);
        if (noFlush && willSnapshot && windowUtils().flushApzRepaints()) {
          LogInfo("MakeProgress: done requesting APZ flush");
        } else {
          LogInfo("MakeProgress: APZ flush not required");
          flushWaiter(null, null, null);
        }
        return;

      case STATE_WAITING_FOR_APZ_FLUSH:
        LogInfo("MakeProgress: STATE_WAITING_FOR_APZ_FLUSH");
        // Nothing to do here; once we get the apz-repaints-flushed event
        // we will go to STATE_WAITING_TO_FINISH
        return;

      case STATE_WAITING_TO_FINISH:
        LogInfo("MakeProgress: STATE_WAITING_TO_FINISH");
        if (shouldWaitForPendingPaints() || updateCanvasPending) {
          gFailureReason =
            "timed out waiting for pending paint count to " +
            "reach zero (after reftest-wait removed and switch to print mode)";
          if (shouldWaitForPendingPaints()) {
            gFailureReason += " (waiting for MozAfterPaint)";
            LogInfo("MakeProgress: waiting for MozAfterPaint");
          }
          if (updateCanvasPending) {
            gFailureReason += " (waiting for updateCanvasPending)";
            LogInfo("MakeProgress: waiting for updateCanvasPending");
          }
          return;
        }
        CheckForLivenessOfContentRootElement();
        if (contentRootElement) {
          let elements = getNoPaintElements(contentRootElement);
          for (let i = 0; i < elements.length; ++i) {
            if (windowUtils().checkAndClearPaintedState(elements[i])) {
              SendFailedNoPaint();
            }
          }
          // We only support retained display lists in the content process
          // right now, so don't fail reftest-no-display-list tests when
          // we don't have e10s.
          if (gBrowserIsRemote) {
            elements = getNoDisplayListElements(contentRootElement);
            for (let i = 0; i < elements.length; ++i) {
              if (windowUtils().checkAndClearDisplayListState(elements[i])) {
                SendFailedNoDisplayList();
              }
            }
            elements = getDisplayListElements(contentRootElement);
            for (let i = 0; i < elements.length; ++i) {
              if (!windowUtils().checkAndClearDisplayListState(elements[i])) {
                SendFailedDisplayList();
              }
            }
          }
        }

        if (!IsSnapshottableTestType()) {
          // If we're not snapshotting the test, at least do a sync round-trip
          // to the compositor to ensure that all the rendering messages
          // related to this test get processed. Otherwise problems triggered
          // by this test may only manifest as failures in a later test.
          LogInfo("MakeProgress: Doing sync flush to compositor");
          gFailureReason = "timed out while waiting for sync compositor flush";
          windowUtils().syncFlushCompositor();
        }

        LogInfo("MakeProgress: Completed");
        state = STATE_COMPLETED;
        gFailureReason = "timed out while taking snapshot (bug in harness?)";
        RemoveListeners();
        CheckForLivenessOfContentRootElement();
        CheckForProcessCrashExpectation(contentRootElement);
        setTimeout(RecordResult, 0, forURL);
    }
  }

  LogInfo("WaitForTestEnd: Adding listeners");
  addEventListener("MozAfterPaint", AfterPaintListener, false);
  addEventListener(
    "Reftest:MozAfterPaintFromChild",
    FromChildAfterPaintListener,
    false
  );

  // If contentRootElement is null then shouldWaitForReftestWaitRemoval will
  // always return false so we don't need a listener anyway
  CheckForLivenessOfContentRootElement();
  if (contentRootElement?.hasAttribute("class")) {
    attrModifiedObserver =
      // ownerGlobal doesn't exist in content windows.
      // eslint-disable-next-line mozilla/use-ownerGlobal
      new contentRootElement.ownerDocument.defaultView.MutationObserver(
        AttrModifiedListener
      );
    attrModifiedObserver.observe(contentRootElement, { attributes: true });
  }
  gTimeoutHook = RemoveListeners;

  // Listen for spell checks on spell-checked elements.
  var numPendingSpellChecks = spellCheckedElements.length;
  function decNumPendingSpellChecks() {
    --numPendingSpellChecks;
    if (operationInProgress) {
      CallSetTimeoutMakeProgress();
    } else {
      MakeProgress();
    }
  }
  for (let editable of spellCheckedElements) {
    try {
      onSpellCheck(editable, decNumPendingSpellChecks);
    } catch (err) {
      // The element may not have an editor, so ignore it.
      setTimeout(decNumPendingSpellChecks, 0);
    }
  }

  // Take a full snapshot now that all our listeners are set up. This
  // ensures it's impossible for us to miss updates between taking the snapshot
  // and adding our listeners.
  OperationInProgress();
  let promise = SendInitCanvasWithSnapshot(forURL);
  promise.then(function () {
    OperationCompleted();
    MakeProgress();
  });
}

async function OnDocumentLoad(uri) {
  if (gClearingForAssertionCheck) {
    if (uri == BLANK_URL_FOR_CLEARING) {
      DoAssertionCheck();
      return;
    }

    // It's likely the previous test document reloads itself and causes the
    // attempt of loading blank page fails. In this case we should retry
    // loading the blank page.
    LogInfo("Retry loading a blank page");
    setTimeout(LoadURI, 0, BLANK_URL_FOR_CLEARING);
    return;
  }

  if (uri != gCurrentURL) {
    LogInfo("OnDocumentLoad fired for previous document");
    // Ignore load events for previous documents.
    return;
  }

  var currentDoc = content && content.document;

  // Collect all editable, spell-checked elements.  It may be the case that
  // not all the elements that match this selector will be spell checked: for
  // example, a textarea without a spellcheck attribute may have a parent with
  // spellcheck=false, or script may set spellcheck=false on an element whose
  // markup sets it to true.  But that's OK since onSpellCheck detects the
  // absence of spell checking, too.
  var querySelector =
    '*[class~="spell-checked"],' +
    'textarea:not([spellcheck="false"]),' +
    'input[spellcheck]:-moz-any([spellcheck=""],[spellcheck="true"]),' +
    '*[contenteditable]:-moz-any([contenteditable=""],[contenteditable="true"])';
  var spellCheckedElements = currentDoc
    ? currentDoc.querySelectorAll(querySelector)
    : [];

  var contentRootElement = currentDoc ? currentDoc.documentElement : null;
  currentDoc = null;
  setupFullZoom(contentRootElement);
  setupTextZoom(contentRootElement);
  setupViewport(contentRootElement);
  await setupDisplayport(contentRootElement);
  var inPrintMode = false;

  async function AfterOnLoadScripts() {
    // Regrab the root element, because the document may have changed.
    var contentRootElement = content.document
      ? content.document.documentElement
      : null;

    // Flush the document in case it got modified in a load event handler.
    await FlushRendering(FlushMode.ALL);

    // Take a snapshot now.
    let painted = await SendInitCanvasWithSnapshot(uri);

    if (contentRootElement && Cu.isDeadWrapper(contentRootElement)) {
      contentRootElement = null;
    }

    if (
      (!inPrintMode && doPrintMode(contentRootElement)) ||
      // If we didn't force a paint above, in
      // InitCurrentCanvasWithSnapshot, so we should wait for a
      // paint before we consider them done.
      !painted
    ) {
      LogInfo("AfterOnLoadScripts belatedly entering WaitForTestEnd");
      // Go into reftest-wait mode belatedly.
      WaitForTestEnd(contentRootElement, inPrintMode, [], uri);
    } else {
      CheckForProcessCrashExpectation(contentRootElement);
      RecordResult(uri);
    }
  }

  if (
    shouldWaitForReftestWaitRemoval(contentRootElement) ||
    spellCheckedElements.length
  ) {
    // Go into reftest-wait mode immediately after painting has been
    // unsuppressed, after the onload event has finished dispatching.
    gFailureReason =
      "timed out waiting for test to complete (trying to get into WaitForTestEnd)";
    LogInfo("OnDocumentLoad triggering WaitForTestEnd");
    setTimeout(function () {
      WaitForTestEnd(
        contentRootElement,
        inPrintMode,
        spellCheckedElements,
        uri
      );
    }, 0);
  } else {
    if (doPrintMode(contentRootElement)) {
      LogInfo("OnDocumentLoad setting up print mode");
      setupPrintMode(contentRootElement);
      inPrintMode = true;
    }

    // Since we can't use a bubbling-phase load listener from chrome,
    // this is a capturing phase listener.  So do setTimeout twice, the
    // first to get us after the onload has fired in the content, and
    // the second to get us after any setTimeout(foo, 0) in the content.
    gFailureReason =
      "timed out waiting for test to complete (waiting for onload scripts to complete)";
    LogInfo("OnDocumentLoad triggering AfterOnLoadScripts");
    setTimeout(function () {
      setTimeout(AfterOnLoadScripts, 0);
    }, 0);
  }
}

function CheckForProcessCrashExpectation(contentRootElement) {
  if (
    contentRootElement &&
    contentRootElement.hasAttribute("class") &&
    contentRootElement
      .getAttribute("class")
      .split(/\s+/)
      .includes("reftest-expect-process-crash")
  ) {
    SendExpectProcessCrash();
  }
}

async function RecordResult(forURL) {
  if (forURL != gCurrentURL) {
    LogInfo("RecordResult fired for previous document");
    return;
  }

  if (gCurrentURLRecordResults > 0) {
    LogInfo("RecordResult fired extra times");
    FinishTestItem();
    return;
  }
  gCurrentURLRecordResults++;

  LogInfo("RecordResult fired");

  var currentTestRunTime = Date.now() - gCurrentTestStartTime;

  clearTimeout(gFailureTimeout);
  gFailureReason = null;
  gFailureTimeout = null;
  gCurrentURL = null;
  gCurrentURLTargetType = undefined;

  if (gCurrentTestType == TYPE_PRINT) {
    printToPdf();
    return;
  }
  if (gCurrentTestType == TYPE_SCRIPT) {
    var error = "";
    var testwindow = content;

    if (testwindow.wrappedJSObject) {
      testwindow = testwindow.wrappedJSObject;
    }

    var testcases;
    if (
      !testwindow.getTestCases ||
      typeof testwindow.getTestCases != "function"
    ) {
      // Force an unexpected failure to alert the test author to fix the test.
      error = "test must provide a function getTestCases(). (SCRIPT)\n";
    } else if (!(testcases = testwindow.getTestCases())) {
      // Force an unexpected failure to alert the test author to fix the test.
      error =
        "test's getTestCases() must return an Array-like Object. (SCRIPT)\n";
    } else if (!testcases.length) {
      // This failure may be due to a JavaScript Engine bug causing
      // early termination of the test. If we do not allow silent
      // failure, the driver will report an error.
    }

    var results = [];
    if (!error) {
      // FIXME/bug 618176: temporary workaround
      for (var i = 0; i < testcases.length; ++i) {
        var test = testcases[i];
        results.push({
          passed: test.testPassed(),
          description: test.testDescription(),
        });
      }
      //results = testcases.map(function(test) {
      //        return { passed: test.testPassed(),
      //                 description: test.testDescription() };
    }

    SendScriptResults(currentTestRunTime, error, results);
    FinishTestItem();
    return;
  }

  // Setup async scroll offsets now in case SynchronizeForSnapshot is not
  // called (due to reftest-no-sync-layers being supplied, or in the single
  // process case).
  let changedAsyncScrollZoom = await setupAsyncScrollOffsets({
    allowFailure: true,
  });
  if (setupAsyncZoom({ allowFailure: true })) {
    changedAsyncScrollZoom = true;
  }
  if (changedAsyncScrollZoom && !gBrowserIsRemote) {
    sendAsyncMessage("reftest:UpdateWholeCanvasForInvalidation");
  }

  SendTestDone(currentTestRunTime);
  FinishTestItem();
}

function LoadFailed() {
  if (gTimeoutHook) {
    gTimeoutHook();
  }
  gFailureTimeout = null;
  SendFailedLoad(gFailureReason);
}

function FinishTestItem() {
  gHaveCanvasSnapshot = false;
}

function DoAssertionCheck() {
  gClearingForAssertionCheck = false;

  var numAsserts = 0;
  if (gDebug.isDebugBuild) {
    var newAssertionCount = gDebug.assertionCount;
    numAsserts = newAssertionCount - gAssertionCount;
    gAssertionCount = newAssertionCount;
  }
  SendAssertionCount(numAsserts);
}

function LoadURI(uri) {
  let loadURIOptions = {
    triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
  };
  webNavigation().loadURI(Services.io.newURI(uri), loadURIOptions);
}

function LogError(str) {
  if (gVerbose) {
    sendSyncMessage("reftest:Log", { type: "error", msg: str });
  } else {
    sendAsyncMessage("reftest:Log", { type: "error", msg: str });
  }
}

function LogWarning(str) {
  if (gVerbose) {
    sendSyncMessage("reftest:Log", { type: "warning", msg: str });
  } else {
    sendAsyncMessage("reftest:Log", { type: "warning", msg: str });
  }
}

function LogInfo(str) {
  if (gVerbose) {
    sendSyncMessage("reftest:Log", { type: "info", msg: str });
  } else {
    sendAsyncMessage("reftest:Log", { type: "info", msg: str });
  }
}

function IsSnapshottableTestType() {
  // Script, load-only, and PDF-print tests do not need any snapshotting.
  return !(
    gCurrentTestType == TYPE_SCRIPT ||
    gCurrentTestType == TYPE_LOAD ||
    gCurrentTestType == TYPE_PRINT
  );
}

const SYNC_DEFAULT = 0x0;
const SYNC_ALLOW_DISABLE = 0x1;
// Returns a promise that resolve when the snapshot is done.
function SynchronizeForSnapshot(flags) {
  if (!IsSnapshottableTestType()) {
    return Promise.resolve(undefined);
  }

  if (flags & SYNC_ALLOW_DISABLE) {
    var docElt = content.document.documentElement;
    if (
      docElt &&
      (docElt.hasAttribute("reftest-no-sync-layers") || shouldNotFlush(docElt))
    ) {
      LogInfo("Test file chose to skip SynchronizeForSnapshot");
      return Promise.resolve(undefined);
    }
  }

  let browsingContext = content.docShell.browsingContext;
  let promise = content.windowGlobalChild
    .getActor("ReftestFission")
    .sendQuery("UpdateLayerTree", { browsingContext });
  return promise.then(
    function (result) {
      for (let errorString of result.errorStrings) {
        LogError(errorString);
      }
      for (let infoString of result.infoStrings) {
        LogInfo(infoString);
      }

      // Setup async scroll offsets now, because any scrollable layers should
      // have had their AsyncPanZoomControllers created.
      return setupAsyncScrollOffsets({ allowFailure: false }).then(function (
        result
      ) {
        setupAsyncZoom({ allowFailure: false });
      });
    },
    function (reason) {
      // We expect actors to go away causing sendQuery's to fail, so
      // just note it.
      LogInfo("UpdateLayerTree sendQuery to parent rejected: " + reason);

      // Setup async scroll offsets now, because any scrollable layers should
      // have had their AsyncPanZoomControllers created.
      return setupAsyncScrollOffsets({ allowFailure: false }).then(function (
        result
      ) {
        setupAsyncZoom({ allowFailure: false });
      });
    }
  );
}

function RegisterMessageListeners() {
  addMessageListener("reftest:Clear", function (m) {
    RecvClear();
  });
  addMessageListener("reftest:LoadScriptTest", function (m) {
    RecvLoadScriptTest(m.json.uri, m.json.timeout);
  });
  addMessageListener("reftest:LoadPrintTest", function (m) {
    RecvLoadPrintTest(m.json.uri, m.json.timeout);
  });
  addMessageListener("reftest:LoadTest", function (m) {
    RecvLoadTest(m.json.type, m.json.uri, m.json.uriTargetType, m.json.timeout);
  });
  addMessageListener("reftest:ResetRenderingState", function (m) {
    RecvResetRenderingState();
  });
  addMessageListener("reftest:PrintDone", function (m) {
    RecvPrintDone(m.json.status, m.json.fileName);
  });
  addMessageListener("reftest:UpdateCanvasWithSnapshotDone", function (m) {
    RecvUpdateCanvasWithSnapshotDone(m.json.painted);
  });
}

function RecvClear() {
  gClearingForAssertionCheck = true;
  LoadURI(BLANK_URL_FOR_CLEARING);
}

function RecvLoadTest(type, uri, uriTargetType, timeout) {
  StartTestURI(type, uri, uriTargetType, timeout);
}

function RecvLoadScriptTest(uri, timeout) {
  StartTestURI(TYPE_SCRIPT, uri, URL_TARGET_TYPE_TEST, timeout);
}

function RecvLoadPrintTest(uri, timeout) {
  StartTestURI(TYPE_PRINT, uri, URL_TARGET_TYPE_TEST, timeout);
}

function RecvResetRenderingState() {
  resetZoomAndTextZoom();
  resetDisplayportAndViewport();
}

function RecvPrintDone(status, fileName) {
  const currentTestRunTime = Date.now() - gCurrentTestStartTime;
  SendPrintResult(currentTestRunTime, status, fileName);
  FinishTestItem();
}

function RecvUpdateCanvasWithSnapshotDone(painted) {
  gUpdateCanvasPromiseResolver(painted);
}

function SendAssertionCount(numAssertions) {
  sendAsyncMessage("reftest:AssertionCount", { count: numAssertions });
}

function SendContentReady() {
  let gfxInfo =
    NS_GFXINFO_CONTRACTID in Cc &&
    Cc[NS_GFXINFO_CONTRACTID].getService(Ci.nsIGfxInfo);

  let info = {};

  try {
    info.D2DEnabled = gfxInfo.D2DEnabled;
    info.DWriteEnabled = gfxInfo.DWriteEnabled;
    info.EmbeddedInFirefoxReality = gfxInfo.EmbeddedInFirefoxReality;
  } catch (e) {
    info.D2DEnabled = false;
    info.DWriteEnabled = false;
    info.EmbeddedInFirefoxReality = false;
  }

  info.AzureCanvasBackend = gfxInfo.AzureCanvasBackend;
  info.AzureContentBackend = gfxInfo.AzureContentBackend;

  return sendSyncMessage("reftest:ContentReady", { gfx: info })[0];
}

function SendException(what) {
  sendAsyncMessage("reftest:Exception", { what });
}

function SendFailedLoad(why) {
  sendAsyncMessage("reftest:FailedLoad", { why });
}

function SendFailedNoPaint() {
  sendAsyncMessage("reftest:FailedNoPaint");
}

function SendFailedNoDisplayList() {
  sendAsyncMessage("reftest:FailedNoDisplayList");
}

function SendFailedDisplayList() {
  sendAsyncMessage("reftest:FailedDisplayList");
}

function SendFailedOpaqueLayer(why) {
  sendAsyncMessage("reftest:FailedOpaqueLayer", { why });
}

function SendFailedAssignedLayer(why) {
  sendAsyncMessage("reftest:FailedAssignedLayer", { why });
}

// Returns a promise that resolves to a bool that indicates if a snapshot was taken.
async function SendInitCanvasWithSnapshot(forURL) {
  if (forURL != gCurrentURL) {
    LogInfo("SendInitCanvasWithSnapshot called for previous document");
    // Lie and say we painted because it doesn't matter, this is a test we
    // are already done with that is clearing out. Then AfterOnLoadScripts
    // should finish quicker if that is who is calling us.
    return Promise.resolve(true);
  }

  // If we're in the same process as the top-level XUL window, then
  // drawing that window will also update our layers, so no
  // synchronization is needed.
  //
  // NB: this is a test-harness optimization only, it must not
  // affect the validity of the tests.
  if (gBrowserIsRemote) {
    await SynchronizeForSnapshot(SYNC_DEFAULT);
    let promise = new Promise(resolve => {
      gUpdateCanvasPromiseResolver = resolve;
    });
    sendAsyncMessage("reftest:InitCanvasWithSnapshot");

    gHaveCanvasSnapshot = await promise;
    return gHaveCanvasSnapshot;
  }

  // For in-process browser, we have to make a synchronous request
  // here to make the above optimization valid, so that MozWaitPaint
  // events dispatched (synchronously) during painting are received
  // before we check the paint-wait counter.  For out-of-process
  // browser though, it doesn't wrt correctness whether this request
  // is sync or async.
  let promise = new Promise(resolve => {
    gUpdateCanvasPromiseResolver = resolve;
  });
  sendAsyncMessage("reftest:InitCanvasWithSnapshot");

  gHaveCanvasSnapshot = await promise;
  return Promise.resolve(gHaveCanvasSnapshot);
}

function SendScriptResults(runtimeMs, error, results) {
  sendAsyncMessage("reftest:ScriptResults", {
    runtimeMs,
    error,
    results,
  });
}

function SendStartPrint(isPrintSelection, printRange) {
  sendAsyncMessage("reftest:StartPrint", { isPrintSelection, printRange });
}

function SendPrintResult(runtimeMs, status, fileName) {
  sendAsyncMessage("reftest:PrintResult", {
    runtimeMs,
    status,
    fileName,
  });
}

function SendExpectProcessCrash(runtimeMs) {
  sendAsyncMessage("reftest:ExpectProcessCrash");
}

function SendTestDone(runtimeMs) {
  sendAsyncMessage("reftest:TestDone", { runtimeMs });
}

function roundTo(x, fraction) {
  return Math.round(x / fraction) * fraction;
}

function elementDescription(element) {
  return (
    "<" +
    element.localName +
    [].slice
      .call(element.attributes)
      .map(attr => ` ${attr.nodeName}="${attr.value}"`)
      .join("") +
    ">"
  );
}

async function SendUpdateCanvasForEvent(forURL, rectList, contentRootElement) {
  if (forURL != gCurrentURL) {
    LogInfo("SendUpdateCanvasForEvent called for previous document");
    // This is a test we are already done with that is clearing out.
    // Don't do anything.
    return;
  }

  var scale = docShell.browsingContext.fullZoom;

  var rects = [];
  if (shouldSnapshotWholePage(contentRootElement)) {
    // See comments in SendInitCanvasWithSnapshot() re: the split
    // logic here.
    if (!gBrowserIsRemote) {
      sendSyncMessage("reftest:UpdateWholeCanvasForInvalidation");
    } else {
      await SynchronizeForSnapshot(SYNC_ALLOW_DISABLE);
      let promise = new Promise(resolve => {
        gUpdateCanvasPromiseResolver = resolve;
      });
      sendAsyncMessage("reftest:UpdateWholeCanvasForInvalidation");
      await promise;
    }
    return;
  }

  var message;

  if (!windowUtils().isMozAfterPaintPending) {
    // Webrender doesn't have invalidation, and animations on the compositor
    // don't invoke any MozAfterEvent which means we have no invalidated
    // rect so we just invalidate the whole screen once we don't have
    // anymore paints pending. This will force the snapshot.

    LogInfo("Sending update whole canvas for invalidation");
    message = "reftest:UpdateWholeCanvasForInvalidation";
  } else {
    LogInfo("SendUpdateCanvasForEvent with " + rectList.length + " rects");
    for (var i = 0; i < rectList.length; ++i) {
      var r = rectList[i];
      // Set left/top/right/bottom to "device pixel" boundaries
      var left = Math.floor(roundTo(r.left * scale, 0.001));
      var top = Math.floor(roundTo(r.top * scale, 0.001));
      var right = Math.ceil(roundTo(r.right * scale, 0.001));
      var bottom = Math.ceil(roundTo(r.bottom * scale, 0.001));
      LogInfo("Rect: " + left + " " + top + " " + right + " " + bottom);

      rects.push({ left, top, right, bottom });
    }

    message = "reftest:UpdateCanvasForInvalidation";
  }

  // See comments in SendInitCanvasWithSnapshot() re: the split
  // logic here.
  if (!gBrowserIsRemote) {
    sendSyncMessage(message, { rects });
  } else {
    await SynchronizeForSnapshot(SYNC_ALLOW_DISABLE);
    let promise = new Promise(resolve => {
      gUpdateCanvasPromiseResolver = resolve;
    });
    sendAsyncMessage(message, { rects });
    await promise;
  }
}

if (content.document.readyState == "complete") {
  // load event has already fired for content, get started
  OnInitialLoad();
} else {
  addEventListener("load", OnInitialLoad, true);
}