Servo encapsulation and cleanup (#10108)

- Initialize WGPU manually
- Improve code

Author: burhankhanzada

examples/servo/Cargo.lock

@@ -31,6 +31,7 @@ glow = "0.16.0"
 gleam = "0.15.1"
 image = "0.25.8"
 winit = "0.30.12"
+spin_on = "0.1.1"
 rustls = "0.23.34"
 euclid = "0.22.11"
 surfman = "0.10.0"

examples/servo/Cargo.toml

@@ -35,18 +35,20 @@ pub struct SlintServoAdapter {
 pub struct SlintServoAdapterInner {
     scale_factor: f32,
     webview: Option<WebView>,
-    rendering_adapter: Option<Box<dyn ServoRenderingAdapter>>,
+    rendering_adapter: Option<Rc<Box<dyn ServoRenderingAdapter>>>,
     #[cfg(not(target_os = "android"))]
-    device: Option<wgpu::Device>,
+    device: wgpu::Device,
     #[cfg(not(target_os = "android"))]
-    queue: Option<wgpu::Queue>,
+    queue: wgpu::Queue,
 }
 
 impl SlintServoAdapter {
     pub fn new(
         app: slint::Weak<MyApp>,
         waker_sender: Sender<()>,
         waker_receiver: Receiver<()>,
+        #[cfg(not(target_os = "android"))] device: wgpu::Device,
+        #[cfg(not(target_os = "android"))] queue: wgpu::Queue,
     ) -> Self {
         Self {
             app,
@@ -58,9 +60,9 @@ impl SlintServoAdapter {
                 scale_factor: 1.0,
                 rendering_adapter: None,
                 #[cfg(not(target_os = "android"))]
-                device: None,
+                device: device,
                 #[cfg(not(target_os = "android"))]
-                queue: None,
+                queue: queue,
             }),
         }
     }
@@ -91,12 +93,12 @@ impl SlintServoAdapter {
 
     #[cfg(not(target_os = "android"))]
     pub fn wgpu_device(&self) -> wgpu::Device {
-        self.inner().device.as_ref().expect("Device not initialized yet").clone()
+        self.inner().device.clone()
     }
 
     #[cfg(not(target_os = "android"))]
     pub fn wgpu_queue(&self) -> wgpu::Queue {
-        self.inner().queue.as_ref().expect("Queue not initialized yet").clone()
+        self.inner().queue.clone()
     }
 
     pub fn webview(&self) -> WebView {
@@ -108,7 +110,7 @@ impl SlintServoAdapter {
         servo: Servo,
         webview: WebView,
         scale_factor: f32,
-        rendering_adapter: Box<dyn ServoRenderingAdapter>,
+        rendering_adapter: Rc<Box<dyn ServoRenderingAdapter>>,
     ) {
         *self.servo.borrow_mut() = Some(servo);
         let mut inner = self.inner_mut();
@@ -117,13 +119,6 @@ impl SlintServoAdapter {
         inner.rendering_adapter = Some(rendering_adapter);
     }
 
-    #[cfg(not(target_os = "android"))]
-    pub fn set_wgpu_device_queue(&self, device: &wgpu::Device, queue: &wgpu::Queue) {
-        let mut inner = self.inner_mut();
-        inner.device = Some(device.clone());
-        inner.queue = Some(queue.clone());
-    }
-
     /// Captures the current Servo framebuffer and updates the Slint UI with the rendered content.
     /// This bridges the rendering output from Servo to the Slint display surface.
     pub fn update_web_content_with_latest_frame(&self) {

examples/servo/src/adapter.rs

@@ -16,65 +16,56 @@ mod gl_bindings {
 }
 
 use slint::ComponentHandle;
-use smol::channel;
-use std::rc::Rc;
 
-use crate::{
-    adapter::{SlintServoAdapter, upgrade_adapter},
-    on_events::on_app_callbacks,
-    servo_util::{init_servo_webview, spin_servo_event_loop},
-};
+use crate::servo_util::init_servo;
 
 slint::include_modules!();
 
-#[cfg(not(target_os = "android"))]
-use slint::wgpu_27::{WGPUConfiguration, WGPUSettings, wgpu};
-
 pub fn main() {
-    let (waker_sender, waker_receiver) = channel::unbounded::<()>();
-
     #[cfg(not(target_os = "android"))]
-    {
-        let mut wgpu_settings = WGPUSettings::default();
-        wgpu_settings.device_required_features = wgpu::Features::PUSH_CONSTANTS;
-        wgpu_settings.device_required_limits.max_push_constant_size = 16; // Maximum push size
+    let (device, queue) = {
+        let backends = wgpu::Backends::from_env().unwrap_or_default();
+
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
+            backends,
+            flags: Default::default(),
+            backend_options: Default::default(),
+            memory_budget_thresholds: Default::default(),
+        });
+
+        let adapter = spin_on::spin_on(async {
+            instance
+                .request_adapter(&Default::default())
+                .await
+                .expect("Failed to find an appropriate WGPU adapter")
+        });
+
+        let (device, queue) = spin_on::spin_on(async {
+            adapter.request_device(&Default::default()).await.expect("Failed to create WGPU device")
+        });
 
         slint::BackendSelector::new()
-        .require_wgpu_27(WGPUConfiguration::Automatic(wgpu_settings))
+        .require_wgpu_27(slint::wgpu_27::WGPUConfiguration::Manual {
+            instance,
+            adapter,
+            device: device.clone(),
+            queue: queue.clone()
+        })
         .select()
         .expect("Failed to create Slint backend with WGPU based renderer - ensure your system supports WGPU");
-    }
-
-    let app = MyApp::new().expect("Failed to create Slint application - check UI resources");
 
-    let app_weak = app.as_weak();
+        (device, queue)
+    };
 
-    let adapter =
-        Rc::new(SlintServoAdapter::new(app_weak, waker_sender.clone(), waker_receiver.clone()));
+    let app = MyApp::new().expect("Failed to create Slint application - check UI resources");
 
-    let adapter_weak = Rc::downgrade(&adapter);
+    let url = "https://slint.dev";
 
     #[cfg(not(target_os = "android"))]
-    app.window()
-        .set_rendering_notifier(move |rendering_state, graphics_api| match rendering_state {
-            slint::RenderingState::RenderingSetup => {
-                if let slint::GraphicsAPI::WGPU27 { device, queue, .. } = graphics_api {
-                    let adpater = upgrade_adapter(&adapter_weak);
-                    adpater.set_wgpu_device_queue(device, queue);
-                }
-            }
-            slint::RenderingState::BeforeRendering => {}
-            slint::RenderingState::AfterRendering => {}
-            slint::RenderingState::RenderingTeardown => {}
-            _ => {}
-        })
-        .expect("Failed to set rendering notifier - WGPU integration may not be available");
-
-    init_servo_webview(adapter.clone(), "https://slint.dev".into());
-
-    spin_servo_event_loop(adapter.clone());
+    let _adapter = init_servo(app.clone_strong(), url.into(), device, queue);
 
-    on_app_callbacks(adapter.clone());
+    #[cfg(target_os = "android")]
+    let _adapter = init_servo(app.clone_strong(), url.into());
 
     app.run().expect("Application failed to run - check for runtime errors");
 }