tor-browser

ReftestFissionChild.sys.mjs (12861B)

---

export class ReftestFissionChild extends JSWindowActorChild {
 forwardAfterPaintEventToParent(
   rects,
   originalTargetUri,
   dispatchToSelfAsWell
 ) {
   if (dispatchToSelfAsWell && this.contentWindow) {
     let event = new this.contentWindow.CustomEvent(
       "Reftest:MozAfterPaintFromChild",
       { bubbles: true, detail: { rects, originalTargetUri } }
     );
     this.contentWindow.dispatchEvent(event);
   }

   let parentContext = this.browsingContext.parent;
   if (parentContext) {
     try {
       this.sendAsyncMessage("ForwardAfterPaintEvent", {
         toBrowsingContext: parentContext,
         fromBrowsingContext: this.browsingContext,
         rects,
         originalTargetUri,
       });
     } catch (e) {
       // |this| can be destroyed here and unable to send messages, which is
       // not a problem, the reftest harness probably torn down the page and
       // moved on to the next test.
       console.error(e);
     }
   }
 }

 handleEvent(evt) {
   switch (evt.type) {
     case "MozAfterPaint":
       // We want to forward any after paint events to our parent document so that
       // that it reaches the root content document where the main reftest harness
       // code (reftest-content.js) will process it and update the canvas.
       var rects = [];
       for (let r of evt.clientRects) {
         rects.push({
           left: r.left,
           top: r.top,
           right: r.right,
           bottom: r.bottom,
         });
       }
       this.forwardAfterPaintEventToParent(
         rects,
         this.document.documentURI,
         /* dispatchToSelfAsWell */ false
       );
       break;
   }
 }

 transformRect(transform, rect) {
   let p1 = transform.transformPoint({ x: rect.left, y: rect.top });
   let p2 = transform.transformPoint({ x: rect.right, y: rect.top });
   let p3 = transform.transformPoint({ x: rect.left, y: rect.bottom });
   let p4 = transform.transformPoint({ x: rect.right, y: rect.bottom });
   let quad = new DOMQuad(p1, p2, p3, p4);
   return quad.getBounds();
 }

 SetupDisplayportRoot() {
   let returnStrings = { infoStrings: [], errorStrings: [] };

   let contentRootElement = this.contentWindow.document.documentElement;
   if (!contentRootElement) {
     return Promise.resolve(returnStrings);
   }

   // If we don't have the reftest-async-scroll attribute we only look at
   // the root element for potential display ports to set.
   if (!contentRootElement.hasAttribute("reftest-async-scroll")) {
     let winUtils = this.contentWindow.windowUtils;
     this.setupDisplayportForElement(
       contentRootElement,
       winUtils,
       returnStrings
     );
     return Promise.resolve(returnStrings);
   }

   // Send a msg to the parent side to get the parent side to tell all
   // process roots to do the displayport setting.
   let browsingContext = this.browsingContext;
   let promise = this.sendQuery("TellChildrenToSetupDisplayport", {
     browsingContext,
   });
   return promise.then(
     function (result) {
       for (let errorString of result.errorStrings) {
         returnStrings.errorStrings.push(errorString);
       }
       for (let infoString of result.infoStrings) {
         returnStrings.infoStrings.push(infoString);
       }
       return returnStrings;
     },
     function (reason) {
       returnStrings.errorStrings.push(
         "SetupDisplayport SendQuery to parent promise rejected: " + reason
       );
       return returnStrings;
     }
   );
 }

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

 setupDisplayportForElement(element, winUtils, returnStrings) {
   var dpw = this.attrOrDefault(element, "reftest-displayport-w", 0);
   var dph = this.attrOrDefault(element, "reftest-displayport-h", 0);
   var dpx = this.attrOrDefault(element, "reftest-displayport-x", 0);
   var dpy = this.attrOrDefault(element, "reftest-displayport-y", 0);
   if (dpw !== 0 || dph !== 0 || dpx != 0 || dpy != 0) {
     returnStrings.infoStrings.push(
       "Setting displayport to <x=" +
         dpx +
         ", y=" +
         dpy +
         ", w=" +
         dpw +
         ", h=" +
         dph +
         ">"
     );
     winUtils.setDisplayPortForElement(dpx, dpy, dpw, dph, element, 1);
   }
 }

 setupDisplayportForElementSubtree(element, winUtils, returnStrings) {
   this.setupDisplayportForElement(element, winUtils, returnStrings);
   for (let c = element.firstElementChild; c; c = c.nextElementSibling) {
     this.setupDisplayportForElementSubtree(c, winUtils, returnStrings);
   }
   if (
     typeof element.contentDocument !== "undefined" &&
     element.contentDocument
   ) {
     returnStrings.infoStrings.push(
       "setupDisplayportForElementSubtree descending into subdocument"
     );
     this.setupDisplayportForElementSubtree(
       element.contentDocument.documentElement,
       element.contentWindow.windowUtils,
       returnStrings
     );
   }
 }

 setupAsyncScrollOffsetsForElement(
   element,
   winUtils,
   allowFailure,
   returnStrings
 ) {
   let sx = this.attrOrDefault(element, "reftest-async-scroll-x", 0);
   let sy = this.attrOrDefault(element, "reftest-async-scroll-y", 0);
   if (sx != 0 || sy != 0) {
     try {
       // This might fail when called from RecordResult since layers
       // may not have been constructed yet
       winUtils.setAsyncScrollOffset(element, sx, sy);
       return true;
     } catch (e) {
       if (allowFailure) {
         returnStrings.infoStrings.push(
           "setupAsyncScrollOffsetsForElement error calling setAsyncScrollOffset: " +
             e
         );
       } else {
         returnStrings.errorStrings.push(
           "setupAsyncScrollOffsetsForElement error calling setAsyncScrollOffset: " +
             e
         );
       }
     }
   }
   return false;
 }

 setupAsyncScrollOffsetsForElementSubtree(
   element,
   winUtils,
   allowFailure,
   returnStrings
 ) {
   let updatedAny = this.setupAsyncScrollOffsetsForElement(
     element,
     winUtils,
     returnStrings
   );
   for (let c = element.firstElementChild; c; c = c.nextElementSibling) {
     if (
       this.setupAsyncScrollOffsetsForElementSubtree(
         c,
         winUtils,
         allowFailure,
         returnStrings
       )
     ) {
       updatedAny = true;
     }
   }
   if (
     typeof element.contentDocument !== "undefined" &&
     element.contentDocument
   ) {
     returnStrings.infoStrings.push(
       "setupAsyncScrollOffsetsForElementSubtree Descending into subdocument"
     );
     if (
       this.setupAsyncScrollOffsetsForElementSubtree(
         element.contentDocument.documentElement,
         element.contentWindow.windowUtils,
         allowFailure,
         returnStrings
       )
     ) {
       updatedAny = true;
     }
   }
   return updatedAny;
 }

 async receiveMessage(msg) {
   switch (msg.name) {
     case "ForwardAfterPaintEventToSelfAndParent": {
       // The embedderElement can be null if the child we got this from was removed.
       // Not much we can do to transform the rects, but it doesn't matter, the rects
       // won't reach reftest-content.js.
       if (msg.data.fromBrowsingContext.embedderElement == null) {
         this.forwardAfterPaintEventToParent(
           msg.data.rects,
           msg.data.originalTargetUri,
           /* dispatchToSelfAsWell */ true
         );
         return undefined;
       }

       let translate = new DOMMatrixReadOnly().translate(0, 0);
       if (this.contentWindow) {
         // Transform the rects from fromBrowsingContext to us.
         // We first translate from the content rect to the border rect of the iframe.
         let style = this.contentWindow.getComputedStyle(
           msg.data.fromBrowsingContext.embedderElement
         );
         translate = new DOMMatrixReadOnly().translate(
           parseFloat(style.paddingLeft) + parseFloat(style.borderLeftWidth),
           parseFloat(style.paddingTop) + parseFloat(style.borderTopWidth)
         );
       }

       // Then we transform from the iframe to our root frame.
       // We are guaranteed to be the process with the embedderElement for fromBrowsingContext.
       let transform =
         msg.data.fromBrowsingContext.embedderElement.getTransformToViewport();
       let combined = translate.multiply(transform);

       let newrects = msg.data.rects.map(r => this.transformRect(combined, r));

       this.forwardAfterPaintEventToParent(
         newrects,
         msg.data.originalTargetUri,
         /* dispatchToSelfAsWell */ true
       );
       break;
     }

     case "EmptyMessage":
       return undefined;
     case "UpdateLayerTree": {
       let errorStrings = [];
       try {
         if (this.manager.isProcessRoot) {
           this.contentWindow.windowUtils.updateLayerTree();
         }
       } catch (e) {
         errorStrings.push("updateLayerTree failed: " + e);
       }
       return { errorStrings };
     }
     case "FlushRendering": {
       let errorStrings = [];
       let warningStrings = [];
       let infoStrings = [];

       try {
         let { ignoreThrottledAnimations, needsAnimationFrame } = msg.data;

         if (this.manager.isProcessRoot) {
           var anyPendingPaintsGeneratedInDescendants = false;

           if (this.contentWindow && needsAnimationFrame) {
             await new Promise(resolve =>
               this.contentWindow.requestAnimationFrame(resolve)
             );
           }

           function flushWindow(win) {
             var utils = win.windowUtils;
             var afterPaintWasPending = utils.isMozAfterPaintPending;

             var root = win.document.documentElement;
             if (root && !root.classList.contains("reftest-no-flush")) {
               try {
                 if (ignoreThrottledAnimations) {
                   utils.flushLayoutWithoutThrottledAnimations();
                 } else {
                   root.getBoundingClientRect();
                 }
               } catch (e) {
                 warningStrings.push("flushWindow failed: " + e + "\n");
               }
             }

             if (!afterPaintWasPending && utils.isMozAfterPaintPending) {
               infoStrings.push(
                 "FlushRendering generated paint for window " +
                   win.location.href
               );
               anyPendingPaintsGeneratedInDescendants = true;
             }

             for (let i = 0; i < win.frames.length; ++i) {
               try {
                 if (!Cu.isRemoteProxy(win.frames[i])) {
                   flushWindow(win.frames[i]);
                 }
               } catch (e) {
                 console.error(e);
               }
             }
           }

           // `contentWindow` will be null if the inner window for this actor
           // has been navigated away from.
           if (this.contentWindow) {
             flushWindow(this.contentWindow);
           }

           if (
             anyPendingPaintsGeneratedInDescendants &&
             !this.contentWindow.windowUtils.isMozAfterPaintPending
           ) {
             warningStrings.push(
               "Internal error: descendant frame generated a MozAfterPaint event, but the root document doesn't have one!"
             );
           }
         }
       } catch (e) {
         errorStrings.push("flushWindow failed: " + e);
       }
       return { errorStrings, warningStrings, infoStrings };
     }

     case "SetupDisplayport": {
       let contentRootElement = this.document.documentElement;
       let winUtils = this.contentWindow.windowUtils;
       let returnStrings = { infoStrings: [], errorStrings: [] };
       if (contentRootElement) {
         this.setupDisplayportForElementSubtree(
           contentRootElement,
           winUtils,
           returnStrings
         );
       }
       return returnStrings;
     }

     case "SetupAsyncScrollOffsets": {
       let returns = { infoStrings: [], errorStrings: [], updatedAny: false };
       let contentRootElement = this.document.documentElement;

       if (!contentRootElement) {
         return returns;
       }

       let winUtils = this.contentWindow.windowUtils;

       returns.updatedAny = this.setupAsyncScrollOffsetsForElementSubtree(
         contentRootElement,
         winUtils,
         msg.data.allowFailure,
         returns
       );
       return returns;
     }
   }
   return undefined;
 }
}