libservo: Expose a ServoBuilder (#36549)

Expose a `ServoBuilder` for easily creating Servo instances using
default values. This change enables removing `EmbedderTraits`.

Testing: This is covered by `Servo` unit tests.
Signed-off-by: Martin Robinson <mrobinson@igalia.com>

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

ports/servoshell/desktop/app.rs

@@ -11,16 +11,14 @@ use std::rc::Rc;
 use std::time::Instant;
 use std::{env, fs};
 
+use ::servo::ServoBuilder;
 use log::{info, trace, warn};
+use net::protocols::ProtocolRegistry;
+use servo::EventLoopWaker;
 use servo::config::opts::Opts;
 use servo::config::prefs::Preferences;
-use servo::servo_config::pref;
 use servo::servo_url::ServoUrl;
 use servo::user_content_manager::{UserContentManager, UserScript};
-use servo::webxr::glwindow::GlWindowDiscovery;
-#[cfg(target_os = "windows")]
-use servo::webxr::openxr::{AppInfo, OpenXrDiscovery};
-use servo::{EventLoopWaker, Servo};
 use url::Url;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
@@ -32,8 +30,9 @@ use super::events_loop::{EventsLoop, WakerEvent};
 use super::minibrowser::{Minibrowser, MinibrowserEvent};
 use super::{headed_window, headless_window};
 use crate::desktop::app_state::RunningAppState;
-use crate::desktop::embedder::{EmbedderCallbacks, XrDiscovery};
+use crate::desktop::protocols;
 use crate::desktop::tracing::trace_winit_event;
+use crate::desktop::webxr::XrDiscoveryWebXrRegistry;
 use crate::desktop::window_trait::WindowPortsMethods;
 use crate::parser::{get_default_url, location_bar_input_to_url};
 use crate::prefs::ServoShellPreferences;
@@ -115,26 +114,6 @@ impl App {
         self.suspended.set(false);
         let (_, window) = self.windows.iter().next().unwrap();
 
-        let xr_discovery = if pref!(dom_webxr_openxr_enabled) && !headless {
-            #[cfg(target_os = "windows")]
-            let openxr = {
-                let app_info = AppInfo::new("Servoshell", 0, "Servo", 0);
-                Some(XrDiscovery::OpenXr(OpenXrDiscovery::new(None, app_info)))
-            };
-            #[cfg(not(target_os = "windows"))]
-            let openxr = None;
-
-            openxr
-        } else if pref!(dom_webxr_glwindow_enabled) && !headless {
-            let window = window.new_glwindow(event_loop.unwrap());
-            Some(XrDiscovery::GlWindow(GlWindowDiscovery::new(window)))
-        } else {
-            None
-        };
-
-        // Implements embedder methods, used by libservo and constellation.
-        let embedder = Box::new(EmbedderCallbacks::new(self.waker.clone(), xr_discovery));
-
         let mut user_content_manager = UserContentManager::new();
         for script in load_userscripts(self.servoshell_preferences.userscripts_directory.as_deref())
             .expect("Loading userscripts failed")
@@ -142,13 +121,32 @@ impl App {
             user_content_manager.add_script(script);
         }
 
-        let servo = Servo::new(
-            self.opts.clone(),
-            self.preferences.clone(),
-            window.rendering_context(),
-            embedder,
-            user_content_manager,
+        let mut protocol_registry = ProtocolRegistry::default();
+        protocol_registry.register(
+            "urlinfo",
+            protocols::urlinfo::UrlInfoProtocolHander::default(),
         );
+        protocol_registry.register("servo", protocols::servo::ServoProtocolHandler::default());
+        protocol_registry.register(
+            "resource",
+            protocols::resource::ResourceProtocolHandler::default(),
+        );
+
+        let servo_builder = ServoBuilder::new(window.rendering_context())
+            .opts(self.opts.clone())
+            .preferences(self.preferences.clone())
+            .user_content_manager(user_content_manager)
+            .protocol_registry(protocol_registry)
+            .event_loop_waker(self.waker.clone());
+
+        #[cfg(feature = "webxr")]
+        let servo_builder = servo_builder.webxr_registry(XrDiscoveryWebXrRegistry::new_boxed(
+            window.clone(),
+            event_loop,
+            &self.preferences,
+        ));
+
+        let servo = servo_builder.build();
         servo.setup_logging();
 
         let running_state = Rc::new(RunningAppState::new(

ports/servoshell/desktop/embedder.rs

@@ -1,71 +0,0 @@
-/* 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 https://mozilla.org/MPL/2.0/. */
-
-//! Implements the global methods required by Servo (not window/gl/compositor related).
-
-use net::protocols::ProtocolRegistry;
-use servo::compositing::windowing::EmbedderMethods;
-use servo::servo_config::pref;
-use servo::webxr::glwindow::GlWindowDiscovery;
-#[cfg(target_os = "windows")]
-use servo::webxr::openxr::OpenXrDiscovery;
-use servo::{EmbedderProxy, EventLoopWaker};
-
-use crate::desktop::protocols::{resource, servo as servo_handler, urlinfo};
-
-pub enum XrDiscovery {
-    GlWindow(GlWindowDiscovery),
-    #[cfg(target_os = "windows")]
-    OpenXr(OpenXrDiscovery),
-}
-
-pub struct EmbedderCallbacks {
-    event_loop_waker: Box<dyn EventLoopWaker>,
-    xr_discovery: Option<XrDiscovery>,
-}
-
-impl EmbedderCallbacks {
-    pub fn new(
-        event_loop_waker: Box<dyn EventLoopWaker>,
-        xr_discovery: Option<XrDiscovery>,
-    ) -> EmbedderCallbacks {
-        EmbedderCallbacks {
-            event_loop_waker,
-            xr_discovery,
-        }
-    }
-}
-
-impl EmbedderMethods for EmbedderCallbacks {
-    fn create_event_loop_waker(&mut self) -> Box<dyn EventLoopWaker> {
-        self.event_loop_waker.clone()
-    }
-
-    #[cfg(feature = "webxr")]
-    fn register_webxr(
-        &mut self,
-        xr: &mut servo::webxr::MainThreadRegistry,
-        _embedder_proxy: EmbedderProxy,
-    ) {
-        use servo::webxr::headless::HeadlessMockDiscovery;
-
-        if pref!(dom_webxr_test) {
-            xr.register_mock(HeadlessMockDiscovery::default());
-        } else if let Some(xr_discovery) = self.xr_discovery.take() {
-            match xr_discovery {
-                XrDiscovery::GlWindow(discovery) => xr.register(discovery),
-                #[cfg(target_os = "windows")]
-                XrDiscovery::OpenXr(discovery) => xr.register(discovery),
-            }
-        }
-    }
-
-    fn get_protocol_handlers(&self) -> ProtocolRegistry {
-        let mut registry = ProtocolRegistry::default();
-        registry.register("urlinfo", urlinfo::UrlInfoProtocolHander::default());
-        registry.register("servo", servo_handler::ServoProtocolHandler::default());
-        registry.register("resource", resource::ResourceProtocolHandler::default());
-        registry
-    }
-}

ports/servoshell/desktop/mod.rs

@@ -10,7 +10,6 @@ mod app_state;
 pub(crate) mod cli;
 mod dialog;
 mod egui_glue;
-mod embedder;
 pub(crate) mod events_loop;
 mod gamepad;
 pub mod geometry;
@@ -20,4 +19,5 @@ mod keyutils;
 mod minibrowser;
 mod protocols;
 mod tracing;
+mod webxr;
 mod window_trait;

ports/servoshell/desktop/webxr.rs

@@ -0,0 +1,78 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use servo::config::pref;
+use servo::config::prefs::Preferences;
+use servo::webxr::WebXrRegistry;
+use servo::webxr::glwindow::GlWindowDiscovery;
+#[cfg(target_os = "windows")]
+use servo::webxr::openxr::{AppInfo, OpenXrDiscovery};
+use winit::event_loop::ActiveEventLoop;
+
+use super::window_trait::WindowPortsMethods;
+
+#[cfg(feature = "webxr")]
+enum XrDiscovery {
+    GlWindow(GlWindowDiscovery),
+    #[cfg(target_os = "windows")]
+    OpenXr(OpenXrDiscovery),
+}
+
+#[cfg(feature = "webxr")]
+pub(crate) struct XrDiscoveryWebXrRegistry {
+    xr_discovery: RefCell<Option<XrDiscovery>>,
+}
+
+impl XrDiscoveryWebXrRegistry {
+    pub(crate) fn new_boxed(
+        window: Rc<dyn WindowPortsMethods>,
+        event_loop: Option<&ActiveEventLoop>,
+        preferences: &Preferences,
+    ) -> Box<Self> {
+        let Some(event_loop) = event_loop else {
+            return Box::new(Self {
+                xr_discovery: RefCell::new(None),
+            });
+        };
+
+        let xr_discovery = if preferences.dom_webxr_openxr_enabled {
+            #[cfg(target_os = "windows")]
+            {
+                let app_info = AppInfo::new("Servoshell", 0, "Servo", 0);
+                Some(XrDiscovery::OpenXr(OpenXrDiscovery::new(None, app_info)))
+            }
+            #[cfg(not(target_os = "windows"))]
+            None
+        } else if preferences.dom_webxr_glwindow_enabled {
+            let window = window.new_glwindow(event_loop);
+            Some(XrDiscovery::GlWindow(GlWindowDiscovery::new(window)))
+        } else {
+            None
+        };
+
+        Box::new(Self {
+            xr_discovery: RefCell::new(xr_discovery),
+        })
+    }
+}
+
+#[cfg(feature = "webxr")]
+impl WebXrRegistry for XrDiscoveryWebXrRegistry {
+    fn register(&self, xr: &mut servo::webxr::MainThreadRegistry) {
+        use servo::webxr::headless::HeadlessMockDiscovery;
+
+        if pref!(dom_webxr_test) {
+            xr.register_mock(HeadlessMockDiscovery::default());
+        } else if let Some(xr_discovery) = self.xr_discovery.take() {
+            match xr_discovery {
+                XrDiscovery::GlWindow(discovery) => xr.register(discovery),
+                #[cfg(target_os = "windows")]
+                XrDiscovery::OpenXr(discovery) => xr.register(discovery),
+            }
+        }
+    }
+}

ports/servoshell/egl/android.rs

@@ -20,11 +20,10 @@ use raw_window_handle::{
     AndroidDisplayHandle, AndroidNdkWindowHandle, RawDisplayHandle, RawWindowHandle,
 };
 use servo::{
-    AlertResponse, LoadStatus, MediaSessionActionType, PermissionRequest, SimpleDialog, WebView,
-};
-use simpleservo::{
-    APP, DeviceIntRect, EventLoopWaker, InitOptions, InputMethodType, MediaSessionPlaybackState,
+    AlertResponse, EventLoopWaker, LoadStatus, MediaSessionActionType, PermissionRequest,
+    SimpleDialog, WebView,
 };
+use simpleservo::{APP, DeviceIntRect, InitOptions, InputMethodType, MediaSessionPlaybackState};
 
 use super::app_state::{Coordinates, RunningAppState};
 use super::host_trait::HostTrait;

ports/servoshell/egl/android/simpleservo.rs

@@ -8,18 +8,14 @@ use std::rc::Rc;
 
 use dpi::PhysicalSize;
 use raw_window_handle::{DisplayHandle, RawDisplayHandle, RawWindowHandle, WindowHandle};
-/// The EventLoopWaker::wake function will be called from any thread.
-/// It will be called to notify embedder that some events are available,
-/// and that perform_updates need to be called
-pub use servo::EventLoopWaker;
 pub use servo::webrender_api::units::DeviceIntRect;
-use servo::{self, Servo, resources};
+use servo::{self, EventLoopWaker, ServoBuilder, resources};
 pub use servo::{InputMethodType, MediaSessionPlaybackState, WindowRenderingContext};
 
 use crate::egl::android::resources::ResourceReaderInstance;
-use crate::egl::app_state::{
-    Coordinates, RunningAppState, ServoEmbedderCallbacks, ServoWindowCallbacks,
-};
+#[cfg(feature = "webxr")]
+use crate::egl::app_state::XrDiscoveryWebXrRegistry;
+use crate::egl::app_state::{Coordinates, RunningAppState, ServoWindowCallbacks};
 use crate::egl::host_trait::HostTrait;
 use crate::prefs::{ArgumentParsingResult, parse_command_line_arguments};
 
@@ -85,26 +81,22 @@ pub fn init(
         RefCell::new(init_opts.coordinates),
     ));
 
-    let embedder_callbacks = Box::new(ServoEmbedderCallbacks::new(
-        waker,
-        #[cfg(feature = "webxr")]
-        init_opts.xr_discovery,
-    ));
+    let servo_builder = ServoBuilder::new(rendering_context.clone())
+        .opts(opts)
+        .preferences(preferences)
+        .event_loop_waker(waker);
 
-    let servo = Servo::new(
-        opts,
-        preferences,
-        rendering_context.clone(),
-        embedder_callbacks,
-        Default::default(),
-    );
+    #[cfg(feature = "webxr")]
+    let servo_builder = servo_builder.webxr_registry(Box::new(XrDiscoveryWebXrRegistry::new(
+        init_opts.xr_discovery,
+    )));
 
     APP.with(|app| {
         let app_state = RunningAppState::new(
             init_opts.url,
             init_opts.density,
             rendering_context,
-            servo,
+            servo_builder.build(),
             window_callbacks,
             servoshell_preferences,
         );

ports/servoshell/egl/app_state.rs

@@ -11,18 +11,16 @@ use keyboard_types::{CompositionEvent, CompositionState};
 use log::{debug, error, info, warn};
 use raw_window_handle::{RawWindowHandle, WindowHandle};
 use servo::base::id::WebViewId;
-use servo::compositing::windowing::EmbedderMethods;
 use servo::euclid::{Point2D, Rect, Scale, Size2D, Vector2D};
 use servo::servo_geometry::DeviceIndependentPixel;
 use servo::webrender_api::ScrollLocation;
 use servo::webrender_api::units::{DeviceIntRect, DeviceIntSize, DevicePixel};
 use servo::{
-    AllowOrDenyRequest, ContextMenuResult, EmbedderProxy, EventLoopWaker, ImeEvent, InputEvent,
-    InputMethodType, Key, KeyState, KeyboardEvent, LoadStatus, MediaSessionActionType,
-    MediaSessionEvent, MouseButton, MouseButtonAction, MouseButtonEvent, MouseMoveEvent,
-    NavigationRequest, PermissionRequest, RenderingContext, ScreenGeometry, Servo, ServoDelegate,
-    ServoError, SimpleDialog, TouchEvent, TouchEventType, TouchId, WebView, WebViewBuilder,
-    WebViewDelegate, WindowRenderingContext,
+    AllowOrDenyRequest, ContextMenuResult, ImeEvent, InputEvent, InputMethodType, Key, KeyState,
+    KeyboardEvent, LoadStatus, MediaSessionActionType, MediaSessionEvent, MouseButton,
+    MouseButtonAction, MouseButtonEvent, MouseMoveEvent, NavigationRequest, PermissionRequest,
+    RenderingContext, ScreenGeometry, Servo, ServoDelegate, ServoError, SimpleDialog, TouchEvent,
+    TouchEventType, TouchId, WebView, WebViewBuilder, WebViewDelegate, WindowRenderingContext,
 };
 use url::Url;
 
@@ -682,38 +680,24 @@ impl RunningAppState {
     }
 }
 
-pub(super) struct ServoEmbedderCallbacks {
-    waker: Box<dyn EventLoopWaker>,
-    #[cfg(feature = "webxr")]
-    xr_discovery: Option<servo::webxr::Discovery>,
+#[cfg(feature = "webxr")]
+pub(crate) struct XrDiscoveryWebXrRegistry {
+    xr_discovery: RefCell<Option<servo::webxr::Discovery>>,
 }
 
-impl ServoEmbedderCallbacks {
-    pub(super) fn new(
-        waker: Box<dyn EventLoopWaker>,
-        #[cfg(feature = "webxr")] xr_discovery: Option<servo::webxr::Discovery>,
-    ) -> Self {
+#[cfg(feature = "webxr")]
+impl XrDiscoveryWebXrRegistry {
+    pub(crate) fn new(xr_discovery: Option<servo::webxr::Discovery>) -> Self {
         Self {
-            waker,
-            #[cfg(feature = "webxr")]
-            xr_discovery,
+            xr_discovery: RefCell::new(xr_discovery),
         }
     }
 }
 
-impl EmbedderMethods for ServoEmbedderCallbacks {
-    fn create_event_loop_waker(&mut self) -> Box<dyn EventLoopWaker> {
-        debug!("EmbedderMethods::create_event_loop_waker");
-        self.waker.clone()
-    }
-
-    #[cfg(feature = "webxr")]
-    fn register_webxr(
-        &mut self,
-        registry: &mut servo::webxr::MainThreadRegistry,
-        _embedder_proxy: EmbedderProxy,
-    ) {
-        debug!("EmbedderMethods::register_xr");
+#[cfg(feature = "webxr")]
+impl servo::webxr::WebXrRegistry for XrDiscoveryWebXrRegistry {
+    fn register(&self, registry: &mut servo::webxr::MainThreadRegistry) {
+        debug!("XrDiscoveryWebXrRegistry::register");
         if let Some(discovery) = self.xr_discovery.take() {
             registry.register(discovery);
         }

ports/servoshell/egl/ohos.rs

@@ -22,10 +22,9 @@ use ohos_ime::{AttachOptions, Ime, ImeProxy, RawTextEditorProxy};
 use ohos_ime_sys::types::InputMethod_EnterKeyType;
 use servo::style::Zero;
 use servo::{
-    AlertResponse, InputMethodType, LoadStatus, MediaSessionPlaybackState, PermissionRequest,
-    SimpleDialog, WebView,
+    AlertResponse, EventLoopWaker, InputMethodType, LoadStatus, MediaSessionPlaybackState,
+    PermissionRequest, SimpleDialog, WebView,
 };
-use simpleservo::EventLoopWaker;
 use xcomponent_sys::{
     OH_NativeXComponent, OH_NativeXComponent_Callback, OH_NativeXComponent_GetKeyEvent,
     OH_NativeXComponent_GetKeyEventAction, OH_NativeXComponent_GetKeyEventCode,

ports/servoshell/egl/ohos/simpleservo.rs

@@ -14,16 +14,10 @@ use raw_window_handle::{
     DisplayHandle, OhosDisplayHandle, OhosNdkWindowHandle, RawDisplayHandle, RawWindowHandle,
     WindowHandle,
 };
-/// The EventLoopWaker::wake function will be called from any thread.
-/// It will be called to notify embedder that some events are available,
-/// and that perform_updates need to be called
-pub use servo::EventLoopWaker;
-use servo::{self, Servo, WindowRenderingContext, resources};
+use servo::{self, EventLoopWaker, ServoBuilder, WindowRenderingContext, resources};
 use xcomponent_sys::OH_NativeXComponent;
 
-use crate::egl::app_state::{
-    Coordinates, RunningAppState, ServoEmbedderCallbacks, ServoWindowCallbacks,
-};
+use crate::egl::app_state::{Coordinates, RunningAppState, ServoWindowCallbacks};
 use crate::egl::host_trait::HostTrait;
 use crate::egl::ohos::InitOpts;
 use crate::egl::ohos::resources::ResourceReaderInstance;
@@ -128,19 +122,11 @@ pub fn init(
         RefCell::new(coordinates),
     ));
 
-    let embedder_callbacks = Box::new(ServoEmbedderCallbacks::new(
-        waker,
-        #[cfg(feature = "webxr")]
-        None,
-    ));
-
-    let servo = Servo::new(
-        opts,
-        preferences,
-        rendering_context.clone(),
-        embedder_callbacks,
-        Default::default(),
-    );
+    let servo = ServoBuilder::new(rendering_context.clone())
+        .opts(opts)
+        .preferences(preferences)
+        .event_loop_waker(waker)
+        .build();
 
     let app_state = RunningAppState::new(
         Some(options.url),