script: Do not run layout in a thread (#31346)

* script: Do not run layout in a thread

Instead of spawning a thread for layout that almost always runs
synchronously with script, simply run layout in the script thread.

This is a resurrection of #28708, taking just the bits that remove the
layout thread. It's a complex change and thus is just a first step
toward cleaning up the interface between script and layout. Messages are
still passed from script to layout via a `process()` method and script
proxies some messages to layout from other threads as well.

Big changes:

1. Layout is created in the script thread on Document load, thus every
   live document is guaranteed to have a layout. This isn't completely
   hidden in the interface, but we can safely `unwrap()` on a Document's
   layout.
2. Layout configuration is abstracted away into a LayoutConfig struct
   and the LayoutFactory is a struct passed around by the Constellation.
   This is to avoid having to monomorphize the entire script thread
   for each layout.
3. Instead of having the Constellation block on the layout thread to
   figure out the current epoch and whether there are pending web fonts
   loading, updates are sent synchronously to the Constellation when
   rendering to a screenshot. This practically only used by the WPT.

A couple tests start to fail, which is probably inevitable since removing
the layout thread has introduced timing changes in "exit after load" and
screenshot behavior.

Co-authored-by: Josh Matthews <josh@joshmatthews.net>

* Update test expectations

* Fix some issues found during review

* Clarify some comments

* Address review comments

---------

Co-authored-by: Josh Matthews <josh@joshmatthews.net>

components/shared/script_layout/lib.rs

@@ -13,15 +13,25 @@ pub mod rpc;
 pub mod wrapper_traits;
 
 use std::any::Any;
+use std::borrow::Cow;
 use std::sync::atomic::AtomicIsize;
+use std::sync::Arc;
 
 use atomic_refcell::AtomicRefCell;
 use canvas_traits::canvas::{CanvasId, CanvasMsg};
+use gfx::font_cache_thread::FontCacheThread;
+use gfx_traits::Epoch;
 use ipc_channel::ipc::IpcSender;
 use libc::c_void;
 use malloc_size_of_derive::MallocSizeOf;
-use net_traits::image_cache::PendingImageId;
-use script_traits::UntrustedNodeAddress;
+use metrics::PaintTimeMetrics;
+use msg::constellation_msg::PipelineId;
+use net_traits::image_cache::{ImageCache, PendingImageId};
+use profile_traits::time;
+use script_traits::{
+    ConstellationControlMsg, InitialScriptState, LayoutControlMsg, LayoutMsg, LoadData,
+    UntrustedNodeAddress, WebrenderIpcSender, WindowSizeData,
+};
 use servo_url::{ImmutableOrigin, ServoUrl};
 use style::data::ElementData;
 use webrender_api::ImageKey;
@@ -162,3 +172,57 @@ pub struct PendingImage {
 pub struct HTMLMediaData {
     pub current_frame: Option<(ImageKey, i32, i32)>,
 }
+
+pub struct LayoutConfig {
+    pub id: PipelineId,
+    pub url: ServoUrl,
+    pub is_iframe: bool,
+    pub constellation_chan: IpcSender<LayoutMsg>,
+    pub script_chan: IpcSender<ConstellationControlMsg>,
+    pub image_cache: Arc<dyn ImageCache>,
+    pub font_cache_thread: FontCacheThread,
+    pub time_profiler_chan: time::ProfilerChan,
+    pub webrender_api_sender: WebrenderIpcSender,
+    pub paint_time_metrics: PaintTimeMetrics,
+    pub window_size: WindowSizeData,
+}
+
+pub trait LayoutFactory: Send + Sync {
+    fn create(&self, config: LayoutConfig) -> Box<dyn Layout>;
+}
+
+pub trait Layout {
+    /// Process a single message from script.
+    fn process(&mut self, msg: message::Msg);
+
+    /// Handle a single message from the Constellation.
+    fn handle_constellation_msg(&mut self, msg: LayoutControlMsg);
+
+    /// Handle a a single mesasge from the FontCacheThread.
+    fn handle_font_cache_msg(&mut self);
+
+    /// Return the interface used for scipt queries.
+    /// TODO: Make this part of the the Layout interface itself now that the
+    /// layout thread has been removed.
+    fn rpc(&self) -> Box<dyn rpc::LayoutRPC>;
+
+    /// Whether or not this layout is waiting for fonts from loaded stylesheets to finish loading.
+    fn waiting_for_web_fonts_to_load(&self) -> bool;
+
+    /// The currently laid out Epoch that this Layout has finished.
+    fn current_epoch(&self) -> Epoch;
+}
+
+/// This trait is part of `layout_traits` because it depends on both `script_traits` and also
+/// `LayoutFactory` from this crate. If it was in `script_traits` there would be a circular
+/// dependency.
+pub trait ScriptThreadFactory {
+    /// Create a `ScriptThread`.
+    fn create(
+        state: InitialScriptState,
+        layout_factory: Arc<dyn LayoutFactory>,
+        font_cache_thread: FontCacheThread,
+        load_data: LoadData,
+        user_agent: Cow<'static, str>,
+    );
+}