tor-browser

ReftestFissionParent.sys.mjs (9288B)

---

export class ReftestFissionParent extends JSWindowActorParent {
 tellChildrenToFlushRendering(
   browsingContext,
   ignoreThrottledAnimations,
   needsAnimationFrame
 ) {
   let promises = [];
   this.tellChildrenToFlushRenderingRecursive(
     browsingContext,
     ignoreThrottledAnimations,
     needsAnimationFrame,
     promises
   );
   return Promise.allSettled(promises);
 }

 tellChildrenToFlushRenderingRecursive(
   browsingContext,
   ignoreThrottledAnimations,
   needsAnimationFrame,
   promises
 ) {
   let cwg = browsingContext.currentWindowGlobal;
   if (cwg && cwg.isProcessRoot) {
     let a = cwg.getActor("ReftestFission");
     if (a) {
       let responsePromise = a.sendQuery("FlushRendering", {
         ignoreThrottledAnimations,
         needsAnimationFrame,
       });
       promises.push(responsePromise);
     }
   }

   for (let context of browsingContext.children) {
     this.tellChildrenToFlushRenderingRecursive(
       context,
       ignoreThrottledAnimations,
       needsAnimationFrame,
       promises
     );
   }
 }

 // not including browsingContext
 getNearestProcessRootProperDescendants(browsingContext) {
   let result = [];
   for (let context of browsingContext.children) {
     this.getNearestProcessRootProperDescendantsRecursive(context, result);
   }
   return result;
 }

 getNearestProcessRootProperDescendantsRecursive(browsingContext, result) {
   let cwg = browsingContext.currentWindowGlobal;
   if (cwg && cwg.isProcessRoot) {
     result.push(browsingContext);
     return;
   }
   for (let context of browsingContext.children) {
     this.getNearestProcessRootProperDescendantsRecursive(context, result);
   }
 }

 // tell children and itself
 async tellChildrenToUpdateLayerTree(browsingContext) {
   let errorStrings = [];
   let infoStrings = [];

   let cwg = browsingContext.currentWindowGlobal;
   if (!cwg || !cwg.isProcessRoot) {
     if (cwg) {
       errorStrings.push(
         "tellChildrenToUpdateLayerTree called on a non process root?"
       );
     }
     return { errorStrings, infoStrings };
   }

   let actor = cwg.getActor("ReftestFission");
   if (!actor) {
     return { errorStrings, infoStrings };
   }

   // When we paint a document we also update the EffectsInfo visible rect in
   // nsSubDocumentFrame for any remote subdocuments. This visible rect is
   // used to limit painting for the subdocument in the subdocument's process.
   // So we want to ensure that the IPC message that updates the visible rect
   // to the subdocument's process arrives before we paint the subdocument
   // (otherwise our painting might not be up to date). We do this by sending,
   // and waiting for reply, an "EmptyMessage" to every direct descendant that
   // is in another process. Since we send the "EmptyMessage" after the
   // visible rect update message we know that the visible rect will be
   // updated by the time we hear back from the "EmptyMessage". Then we can
   // ask the subdocument process to paint.

   try {
     let result = await actor.sendQuery("UpdateLayerTree");
     errorStrings.push(...result.errorStrings);
   } catch (e) {
     infoStrings.push(
       "tellChildrenToUpdateLayerTree UpdateLayerTree msg to child rejected: " +
         e
     );
   }

   let descendants =
     actor.getNearestProcessRootProperDescendants(browsingContext);
   for (let context of descendants) {
     let cwg2 = context.currentWindowGlobal;
     if (cwg2) {
       if (!cwg2.isProcessRoot) {
         errorStrings.push(
           "getNearestProcessRootProperDescendants returned a non process root?"
         );
       }
       let actor2 = cwg2.getActor("ReftestFission");
       if (actor2) {
         try {
           await actor2.sendQuery("EmptyMessage");
         } catch (e) {
           infoStrings.push(
             "tellChildrenToUpdateLayerTree EmptyMessage msg to child rejected: " +
               e
           );
         }

         try {
           let result2 = await actor2.tellChildrenToUpdateLayerTree(context);
           errorStrings.push(...result2.errorStrings);
           infoStrings.push(...result2.infoStrings);
         } catch (e) {
           errorStrings.push(
             "tellChildrenToUpdateLayerTree recursive tellChildrenToUpdateLayerTree call rejected: " +
               e
           );
         }
       }
     }
   }

   return { errorStrings, infoStrings };
 }

 tellChildrenToSetupDisplayport(browsingContext, promises) {
   let cwg = browsingContext.currentWindowGlobal;
   if (cwg && cwg.isProcessRoot) {
     let a = cwg.getActor("ReftestFission");
     if (a) {
       let responsePromise = a.sendQuery("SetupDisplayport");
       promises.push(responsePromise);
     }
   }

   for (let context of browsingContext.children) {
     this.tellChildrenToSetupDisplayport(context, promises);
   }
 }

 tellChildrenToSetupAsyncScrollOffsets(
   browsingContext,
   allowFailure,
   promises
 ) {
   let cwg = browsingContext.currentWindowGlobal;
   if (cwg && cwg.isProcessRoot) {
     let a = cwg.getActor("ReftestFission");
     if (a) {
       let responsePromise = a.sendQuery("SetupAsyncScrollOffsets", {
         allowFailure,
       });
       promises.push(responsePromise);
     }
   }

   for (let context of browsingContext.children) {
     this.tellChildrenToSetupAsyncScrollOffsets(
       context,
       allowFailure,
       promises
     );
   }
 }

 receiveMessage(msg) {
   switch (msg.name) {
     case "ForwardAfterPaintEvent": {
       let cwg = msg.data.toBrowsingContext.currentWindowGlobal;
       if (cwg) {
         let a = cwg.getActor("ReftestFission");
         if (a) {
           a.sendAsyncMessage(
             "ForwardAfterPaintEventToSelfAndParent",
             msg.data
           );
         }
       }
       break;
     }
     case "FlushRendering": {
       let promise = this.tellChildrenToFlushRendering(
         msg.data.browsingContext,
         msg.data.ignoreThrottledAnimations,
         msg.data.needsAnimationFrame
       );
       return promise.then(function (results) {
         let errorStrings = [];
         let warningStrings = [];
         let infoStrings = [];
         for (let r of results) {
           if (r.status != "fulfilled") {
             if (r.status == "pending") {
               errorStrings.push(
                 "FlushRendering sendQuery to child promise still pending?"
               );
             } else {
               // We expect actors to go away causing sendQuery's to fail, so
               // just note it.
               infoStrings.push(
                 "FlushRendering sendQuery to child promise rejected: " +
                   r.reason
               );
             }
             continue;
           }

           errorStrings.push(...r.value.errorStrings);
           warningStrings.push(...r.value.warningStrings);
           infoStrings.push(...r.value.infoStrings);
         }
         return { errorStrings, warningStrings, infoStrings };
       });
     }
     case "UpdateLayerTree": {
       return this.tellChildrenToUpdateLayerTree(msg.data.browsingContext);
     }
     case "TellChildrenToSetupDisplayport": {
       let promises = [];
       this.tellChildrenToSetupDisplayport(msg.data.browsingContext, promises);
       return Promise.allSettled(promises).then(function (results) {
         let errorStrings = [];
         let infoStrings = [];
         for (let r of results) {
           if (r.status != "fulfilled") {
             // We expect actors to go away causing sendQuery's to fail, so
             // just note it.
             infoStrings.push(
               "SetupDisplayport sendQuery to child promise rejected: " +
                 r.reason
             );
             continue;
           }

           errorStrings.push(...r.value.errorStrings);
           infoStrings.push(...r.value.infoStrings);
         }
         return { errorStrings, infoStrings };
       });
     }

     case "SetupAsyncScrollOffsets": {
       let promises = [];
       this.tellChildrenToSetupAsyncScrollOffsets(
         this.manager.browsingContext,
         msg.data.allowFailure,
         promises
       );
       return Promise.allSettled(promises).then(function (results) {
         let errorStrings = [];
         let infoStrings = [];
         let updatedAny = false;
         for (let r of results) {
           if (r.status != "fulfilled") {
             // We expect actors to go away causing sendQuery's to fail, so
             // just note it.
             infoStrings.push(
               "SetupAsyncScrollOffsets sendQuery to child promise rejected: " +
                 r.reason
             );
             continue;
           }

           errorStrings.push(...r.value.errorStrings);
           infoStrings.push(...r.value.infoStrings);
           if (r.value.updatedAny) {
             updatedAny = true;
           }
         }
         return { errorStrings, infoStrings, updatedAny };
       });
     }
   }
   return undefined;
 }
}