layout: Allow same ScriptThread <iframe>s to be resized synchronously (#34656)

Post layout, when a `Window` has all of the new `<iframe>` sizes, size
any `Window`s for `Pipeline`s in the same `ScriptThread` synchronously.
This ensures that when laying out from the outermost frame to the
innermost frames, the frames sizes are set properly.

There is still an issue where a non-same-`ScriptThread` `<iframe>` sits
in between two `<iframe>`s of the same origin. According to the
specification these frames should all be synchrnously laid out --
something quite difficult in Servo. This is issue #34655.

This is the first change in a series of changes to improve the
consistency of `<iframe>` loading and sizing.

Fixes #14719.
Fixes #24569.
Fixes #24571.
Fixes #25269.
Fixes #25275.
Fixes #25285.
Fixes #30571.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

components/script/dom/window.rs

@@ -151,7 +151,7 @@ use crate::script_runtime::{
     CanGc, CommonScriptMsg, JSContext, Runtime, ScriptChan, ScriptPort, ScriptThreadEventCategory,
 };
 use crate::script_thread::{
-    ImageCacheMsg, MainThreadScriptChan, MainThreadScriptMsg, ScriptThread,
+    with_script_thread, ImageCacheMsg, MainThreadScriptChan, MainThreadScriptMsg, ScriptThread,
     SendableMainThreadScriptChan,
 };
 use crate::task_manager::TaskManager;
@@ -380,6 +380,8 @@ pub struct Window {
 
     /// Sizes of the various `<iframes>` that we might have on this [`Window`].
     /// This is used to:
+    ///  - Let same-`ScriptThread` `<iframe>`s know synchronously when their
+    ///    size has changed, ensuring that the next layout has the right size.
     ///  - Send the proper size for the `<iframe>` during new-Pipeline creation
     ///    when the `src` attribute changes.
     ///  - Let the `Constellation` know about `BrowsingContext` (one per `<iframe>`)
@@ -1982,6 +1984,24 @@ impl Window {
             return;
         }
 
+        // Batch resize message to any local `Pipeline`s now, rather than waiting for them
+        // to filter asynchronously through the `Constellation`. This allows the new value
+        // to be reflected immediately in layout.
+        let device_pixel_ratio = self.device_pixel_ratio();
+        with_script_thread(|script_thread| {
+            for iframe_size in new_iframe_sizes.values() {
+                script_thread.handle_resize_message(
+                    iframe_size.pipeline_id,
+                    WindowSizeData {
+                        initial_viewport: iframe_size.size,
+                        device_pixel_ratio,
+                    },
+                    // TODO: This might send an extra resize event. This can fixed by explicitly
+                    // supporting `<iframe>` creation when the size isn't known yet.
+                    WindowSizeType::Resize,
+                );
+            }
+        });
         // Send asynchronous updates to `Constellation.`
         let size_messages: Vec<_> = new_iframe_sizes
             .iter()

components/script/script_thread.rs

@@ -1546,8 +1546,10 @@ impl ScriptThread {
         // > the order it is found in the list.
         let documents_in_order = self.documents.borrow().documents_in_order();
 
-        // Note: the spec reads: "for doc in docs" at each step
-        // whereas this runs all steps per doc in docs.
+        // TODO: The specification reads: "for doc in docs" at each step whereas this runs all
+        // steps per doc in docs. Currently `<iframe>` resizing depends on a parent being able to
+        // queue resize events on a child and have those run in the same call to this method, so
+        // that needs to be sorted out to fix this.
         for pipeline_id in documents_in_order.iter() {
             let document = self
                 .documents
@@ -1619,8 +1621,6 @@ impl ScriptThread {
 
             // TODO: Mark paint timing from https://w3c.github.io/paint-timing.
 
-            // TODO(#31871): Update the rendering: consolidate all reflow calls into one here?
-
             #[cfg(feature = "webgpu")]
             document.update_rendering_of_webgpu_canvases();
 
@@ -2828,7 +2828,7 @@ impl ScriptThread {
 
     /// Batch window resize operations into a single "update the rendering" task,
     /// or, if a load is in progress, set the window size directly.
-    fn handle_resize_message(
+    pub(crate) fn handle_resize_message(
         &self,
         id: PipelineId,
         size: WindowSizeData,
@@ -2843,9 +2843,7 @@ impl ScriptThread {
             let mut loads = self.incomplete_loads.borrow_mut();
             if let Some(ref mut load) = loads.iter_mut().find(|load| load.pipeline_id == id) {
                 load.window_size = size;
-                return;
             }
-            warn!("resize sent to nonexistent pipeline");
         })
     }