gfx: Rename WebrenderSurfman to RenderingContext and move to gfx (#31184)

This is a small cleanup that moves and renames this class. The rename is
simply because we are exposing a lot about the details of Servo's
rendering in the API and it makes sense to start thinking about
abstracting that away a bit.

This also moves the struct to `gfx`, which does have an effect on
Servo's dependency graph. This adds a new dependency on gfx to
`compositing`, but `compositing` had a transitive dependency on
gfx before through `canvas`.

Cargo.lock

@@ -640,7 +640,6 @@ dependencies = [
  "time 0.1.45",
  "webrender",
  "webrender_api",
- "webrender_surfman",
  "webrender_traits",
  "webxr",
  "webxr-api",
@@ -858,6 +857,7 @@ dependencies = [
  "embedder_traits",
  "euclid",
  "fnv",
+ "gfx",
  "gfx_traits",
  "gleam",
  "image",
@@ -879,7 +879,6 @@ dependencies = [
  "toml 0.5.9",
  "webrender",
  "webrender_api",
- "webrender_surfman",
  "webxr",
 ]
 
@@ -901,7 +900,6 @@ dependencies = [
  "servo_url",
  "style_traits",
  "webrender_api",
- "webrender_surfman",
 ]
 
 [[package]]
@@ -2004,6 +2002,7 @@ dependencies = [
  "servo_url",
  "smallvec",
  "style",
+ "surfman",
  "truetype",
  "ucd",
  "unicode-bidi",
@@ -3351,7 +3350,6 @@ dependencies = [
  "webgpu",
  "webrender",
  "webrender_api",
- "webrender_surfman",
  "webrender_traits",
  "webxr",
  "webxr-api",
@@ -6858,14 +6856,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "webrender_surfman"
-version = "0.0.1"
-dependencies = [
- "euclid",
- "surfman",
-]
-
 [[package]]
 name = "webrender_traits"
 version = "0.0.1"

components/canvas/Cargo.toml

@@ -41,7 +41,6 @@ surfman = { workspace = true }
 time = { workspace = true, optional = true }
 webrender = { workspace = true }
 webrender_api = { workspace = true }
-webrender_surfman = { path = "../webrender_surfman" }
 webrender_traits = { workspace = true }
 webxr-api = { git = "https://github.com/servo/webxr", features = ["ipc"] }
 webxr = { git = "https://github.com/servo/webxr", features = ["ipc"] }

components/canvas/webgl_mode/inprocess.rs

@@ -8,13 +8,13 @@ use std::sync::{Arc, Mutex};
 use canvas_traits::webgl::{webgl_channel, WebGLContextId, WebGLMsg, WebGLThreads};
 use euclid::default::Size2D;
 use fnv::FnvHashMap;
+use gfx::rendering_context::RenderingContext;
 use log::debug;
 use sparkle::gl::GlType;
 use surfman::chains::{SwapChainAPI, SwapChains, SwapChainsAPI};
 use surfman::{Device, SurfaceInfo, SurfaceTexture};
 use webrender::RenderApiSender;
 use webrender_api::DocumentId;
-use webrender_surfman::WebrenderSurfman;
 use webrender_traits::{
     WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageSource,
 };
@@ -32,7 +32,7 @@ pub struct WebGLComm {
 impl WebGLComm {
     /// Creates a new `WebGLComm` object.
     pub fn new(
-        surfman: WebrenderSurfman,
+        surfman: RenderingContext,
         webrender_api_sender: RenderApiSender,
         webrender_doc: DocumentId,
         external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@@ -72,13 +72,13 @@ impl WebGLComm {
 
 /// Bridge between the webrender::ExternalImage callbacks and the WebGLThreads.
 struct WebGLExternalImages {
-    surfman: WebrenderSurfman,
+    surfman: RenderingContext,
     swap_chains: SwapChains<WebGLContextId, Device>,
     locked_front_buffers: FnvHashMap<WebGLContextId, SurfaceTexture>,
 }
 
 impl WebGLExternalImages {
-    fn new(surfman: WebrenderSurfman, swap_chains: SwapChains<WebGLContextId, Device>) -> Self {
+    fn new(surfman: RenderingContext, swap_chains: SwapChains<WebGLContextId, Device>) -> Self {
         Self {
             surfman,
             swap_chains,

components/compositing/Cargo.toml

@@ -22,6 +22,7 @@ crossbeam-channel = { workspace = true }
 embedder_traits = { workspace = true }
 euclid = { workspace = true }
 fnv = { workspace = true }
+gfx = { path = "../gfx" }
 gfx_traits = { workspace = true }
 gleam = { workspace = true }
 image = { workspace = true }
@@ -42,7 +43,6 @@ style_traits = { workspace = true }
 time = { workspace = true }
 webrender = { workspace = true }
 webrender_api = { workspace = true }
-webrender_surfman = { path = "../webrender_surfman" }
 webxr = { git = "https://github.com/servo/webxr" }
 
 [build-dependencies]

components/compositing/compositor.rs

@@ -21,6 +21,7 @@ use crossbeam_channel::Sender;
 use embedder_traits::Cursor;
 use euclid::{Point2D, Rect, Scale, Transform3D, Vector2D};
 use fnv::{FnvHashMap, FnvHashSet};
+use gfx::rendering_context::RenderingContext;
 use gfx_traits::{Epoch, FontData, WebRenderEpochToU16};
 use image::{DynamicImage, ImageFormat};
 use ipc_channel::ipc;
@@ -54,7 +55,6 @@ use webrender_api::{
     ReferenceFrameKind, ScrollClamping, ScrollLocation, SpaceAndClipInfo, SpatialId,
     TransformStyle, ZoomFactor,
 };
-use webrender_surfman::WebrenderSurfman;
 
 use crate::gl::RenderTargetInfo;
 use crate::touch::{TouchAction, TouchHandler};
@@ -199,7 +199,7 @@ pub struct IOCompositor<Window: WindowMethods + ?Sized> {
     webrender_api: RenderApi,
 
     /// The surfman instance that webrender targets
-    webrender_surfman: WebrenderSurfman,
+    rendering_context: RenderingContext,
 
     /// The GL bindings for webrender
     webrender_gl: Rc<dyn gleam::gl::Gl>,
@@ -403,7 +403,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
             webrender: state.webrender,
             webrender_document: state.webrender_document,
             webrender_api: state.webrender_api,
-            webrender_surfman: state.webrender_surfman,
+            rendering_context: state.rendering_context,
             webrender_gl: state.webrender_gl,
             webxr_main_thread: state.webxr_main_thread,
             pending_paint_metrics: HashMap::new(),
@@ -449,7 +449,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
     }
 
     pub fn deinit(self) {
-        if let Err(err) = self.webrender_surfman.make_gl_context_current() {
+        if let Err(err) = self.rendering_context.make_gl_context_current() {
             warn!("Failed to make GL context current: {:?}", err);
         }
         self.webrender.deinit();
@@ -506,7 +506,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
     /// We need to unbind the surface so that we don't try to use it again.
     pub fn invalidate_native_surface(&mut self) {
         debug!("Invalidating native surface in compositor");
-        if let Err(e) = self.webrender_surfman.unbind_native_surface_from_context() {
+        if let Err(e) = self.rendering_context.unbind_native_surface_from_context() {
             warn!("Unbinding native surface from context failed ({:?})", e);
         }
     }
@@ -517,11 +517,11 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
     #[allow(unsafe_code)]
     pub fn replace_native_surface(&mut self, native_widget: *mut c_void, coords: DeviceIntSize) {
         debug!("Replacing native surface in compositor: {native_widget:?}");
-        let connection = self.webrender_surfman.connection();
+        let connection = self.rendering_context.connection();
         let native_widget =
             unsafe { connection.create_native_widget_from_ptr(native_widget, coords.to_untyped()) };
         if let Err(e) = self
-            .webrender_surfman
+            .rendering_context
             .bind_native_surface_to_context(native_widget)
         {
             warn!("Binding native surface to context failed ({:?})", e);
@@ -1721,7 +1721,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
 
         let size = self.embedder_coordinates.framebuffer.to_u32();
 
-        if let Err(err) = self.webrender_surfman.make_gl_context_current() {
+        if let Err(err) = self.rendering_context.make_gl_context_current() {
             warn!("Failed to make GL context current: {:?}", err);
         }
         self.assert_no_gl_error();
@@ -1765,7 +1765,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
         } else {
             // Bind the webrender framebuffer
             let framebuffer_object = self
-                .webrender_surfman
+                .rendering_context
                 .context_surface_info()
                 .unwrap_or(None)
                 .map(|info| info.framebuffer_object)
@@ -1941,7 +1941,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
     }
 
     pub fn present(&mut self) {
-        if let Err(err) = self.webrender_surfman.present() {
+        if let Err(err) = self.rendering_context.present() {
             warn!("Failed to present surface: {:?}", err);
         }
         self.waiting_on_present = false;
@@ -2049,7 +2049,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
         self.webxr_main_thread.run_one_frame();
 
         // The WebXR thread may make a different context current
-        let _ = self.webrender_surfman.make_gl_context_current();
+        let _ = self.rendering_context.make_gl_context_current();
 
         if !self.pending_scroll_zoom_events.is_empty() && !self.waiting_for_results_of_scroll {
             self.process_pending_scroll_events()

components/compositing/lib.rs

@@ -8,10 +8,10 @@ use std::rc::Rc;
 
 use compositing_traits::{CompositorProxy, CompositorReceiver, ConstellationMsg};
 use crossbeam_channel::Sender;
+use gfx::rendering_context::RenderingContext;
 use profile_traits::{mem, time};
 use webrender::RenderApi;
 use webrender_api::DocumentId;
-use webrender_surfman::WebrenderSurfman;
 
 pub use crate::compositor::{CompositeTarget, IOCompositor, ShutdownState};
 
@@ -36,7 +36,7 @@ pub struct InitialCompositorState {
     pub webrender: webrender::Renderer,
     pub webrender_document: DocumentId,
     pub webrender_api: RenderApi,
-    pub webrender_surfman: WebrenderSurfman,
+    pub rendering_context: RenderingContext,
     pub webrender_gl: Rc<dyn gleam::gl::Gl>,
     pub webxr_main_thread: webxr::MainThreadRegistry,
 }

components/compositing/windowing.rs

@@ -9,6 +9,7 @@ use std::time::Duration;
 
 use embedder_traits::{EmbedderProxy, EventLoopWaker};
 use euclid::Scale;
+use gfx::rendering_context::RenderingContext;
 use keyboard_types::KeyboardEvent;
 use libc::c_void;
 use msg::constellation_msg::{PipelineId, TopLevelBrowsingContextId, TraversalDirection};
@@ -19,7 +20,6 @@ use servo_url::ServoUrl;
 use style_traits::DevicePixel;
 use webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePoint};
 use webrender_api::ScrollLocation;
-use webrender_surfman::WebrenderSurfman;
 
 #[derive(Clone)]
 pub enum MouseWindowEvent {
@@ -177,8 +177,8 @@ pub trait WindowMethods {
     fn get_native_display(&self) -> NativeDisplay;
     /// Get the GL api
     fn get_gl_api(&self) -> GlApi;
-    /// Get the webrender surfman instance
+    /// Get the RenderingContext instance.
-    fn webrender_surfman(&self) -> WebrenderSurfman;
+    fn rendering_context(&self) -> RenderingContext;
 }
 
 pub trait EmbedderMethods {

components/gfx/Cargo.toml

@@ -33,6 +33,7 @@ servo_arc = { path = "../servo_arc" }
 servo_atoms = { path = "../atoms" }
 servo_url = { path = "../url" }
 smallvec = { workspace = true, features = ["union"] }
+surfman = { workspace = true }
 style = { path = "../style", features = ["servo"] }
 ucd = "0.1.1"
 unicode-bidi = { workspace = true, features = ["with_serde"] }

components/gfx/lib.rs

@@ -4,15 +4,11 @@
 
 #![deny(unsafe_code)]
 
-// Fonts
 pub mod font;
 pub mod font_cache_thread;
 pub mod font_context;
 pub mod font_template;
-
-// Platform-specific implementations.
 #[allow(unsafe_code)]
 mod platform;
-
+pub mod rendering_context;
-// Text
 pub mod text;

components/gfx/rendering_context.rs

@@ -16,19 +16,19 @@ use surfman::{
     SurfaceTexture, SurfaceType,
 };
 
-/// A bridge between webrender and surfman
+/// A Servo rendering context, which holds all of the information needed
-// TODO: move this into a different crate so that script doesn't depend on surfman
+/// to render Servo's layout, and bridges WebRender and surfman.
 #[derive(Clone)]
-pub struct WebrenderSurfman(Rc<WebrenderSurfmanData>);
+pub struct RenderingContext(Rc<RenderingContextData>);
 
-struct WebrenderSurfmanData {
+struct RenderingContextData {
     device: RefCell<Device>,
     context: RefCell<Context>,
     // We either render to a swap buffer or to a native widget
     swap_chain: Option<SwapChain<Device>>,
 }
 
-impl Drop for WebrenderSurfmanData {
+impl Drop for RenderingContextData {
     fn drop(&mut self) {
         let ref mut device = self.device.borrow_mut();
         let ref mut context = self.context.borrow_mut();
@@ -39,7 +39,7 @@ impl Drop for WebrenderSurfmanData {
     }
 }
 
-impl WebrenderSurfman {
+impl RenderingContext {
     pub fn create(
         connection: &Connection,
         adapter: &Adapter,
@@ -82,12 +82,12 @@ impl WebrenderSurfman {
         };
         let device = RefCell::new(device);
         let context = RefCell::new(context);
-        let data = WebrenderSurfmanData {
+        let data = RenderingContextData {
             device,
             context,
             swap_chain,
         };
-        Ok(WebrenderSurfman(Rc::new(data)))
+        Ok(RenderingContext(Rc::new(data)))
     }
 
     pub fn create_surface_texture(

components/servo/Cargo.toml

@@ -79,7 +79,6 @@ webdriver_server = { path = "../webdriver_server", optional = true }
 webgpu = { path = "../webgpu" }
 webrender = { workspace = true }
 webrender_api = { workspace = true }
-webrender_surfman = { path = "../webrender_surfman" }
 webrender_traits = { workspace = true }
 webxr = { git = "https://github.com/servo/webxr" }
 webxr-api = { git = "https://github.com/servo/webxr" }

components/servo/lib.rs

@@ -61,6 +61,7 @@ use euclid::Scale;
 ))]
 use gaol::sandbox::{ChildSandbox, ChildSandboxMethods};
 use gfx::font_cache_thread::FontCacheThread;
+pub use gfx::rendering_context;
 pub use gleam::gl;
 use ipc_channel::ipc::{self, IpcSender};
 use log::{error, trace, warn, Log, Metadata, Record};
@@ -89,7 +90,7 @@ pub use {
     keyboard_types, layout_thread_2013, layout_thread_2020, media, msg, net, net_traits, profile,
     profile_traits, script, script_layout_interface, script_traits, servo_config as config,
     servo_config, servo_geometry, servo_url as url, servo_url, style, style_traits, webgpu,
-    webrender_api, webrender_surfman, webrender_traits,
+    webrender_api, webrender_traits,
 };
 
 #[cfg(feature = "webdriver")]
@@ -259,22 +260,22 @@ where
         };
 
         // Initialize surfman
-        let webrender_surfman = window.webrender_surfman();
+        let rendering_context = window.rendering_context();
 
         // Get GL bindings
-        let webrender_gl = match webrender_surfman.connection().gl_api() {
+        let webrender_gl = match rendering_context.connection().gl_api() {
-            GLApi::GL => unsafe { gl::GlFns::load_with(|s| webrender_surfman.get_proc_address(s)) },
+            GLApi::GL => unsafe { gl::GlFns::load_with(|s| rendering_context.get_proc_address(s)) },
             GLApi::GLES => unsafe {
-                gl::GlesFns::load_with(|s| webrender_surfman.get_proc_address(s))
+                gl::GlesFns::load_with(|s| rendering_context.get_proc_address(s))
             },
         };
 
         // Make sure the gl context is made current.
-        webrender_surfman.make_gl_context_current().unwrap();
+        rendering_context.make_gl_context_current().unwrap();
         debug_assert_eq!(webrender_gl.get_error(), gleam::gl::NO_ERROR,);
 
         // Bind the webrender framebuffer
-        let framebuffer_object = webrender_surfman
+        let framebuffer_object = rendering_context
             .context_surface_info()
             .unwrap_or(None)
             .map(|info| info.framebuffer_object)
@@ -369,7 +370,7 @@ where
             webxr_layer_grand_manager,
             image_handler,
         } = WebGLComm::new(
-            webrender_surfman.clone(),
+            rendering_context.clone(),
             webrender_api.create_sender(),
             webrender_document,
             external_images.clone(),
@@ -468,7 +469,7 @@ where
                 webrender,
                 webrender_document,
                 webrender_api,
-                webrender_surfman,
+                rendering_context,
                 webrender_gl,
                 webxr_main_thread,
             },

components/shared/compositing/Cargo.toml

@@ -25,4 +25,3 @@ script_traits = { workspace = true }
 servo_url = { path = "../../url" }
 style_traits = { workspace = true }
 webrender_api = { workspace = true }
-webrender_surfman = { path = "../../webrender_surfman" }

components/webrender_surfman/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "webrender_surfman"
-version = "0.0.1"
-authors = ["The Servo Project Developers"]
-license = "MPL-2.0"
-edition = "2018"
-publish = false
-
-[lib]
-name = "webrender_surfman"
-path = "lib.rs"
-
-[dependencies]
-euclid = { workspace = true }
-surfman = { workspace = true }

ports/jniapi/src/simpleservo.rs

@@ -30,6 +30,7 @@ use servo::euclid::{Point2D, Rect, Scale, Size2D, Vector2D};
 use servo::keyboard_types::{Key, KeyState, KeyboardEvent};
 pub use servo::msg::constellation_msg::InputMethodType;
 use servo::msg::constellation_msg::{TraversalDirection, WebViewId};
+use servo::rendering_context::RenderingContext;
 pub use servo::script_traits::{MediaSessionActionType, MouseButton};
 use servo::script_traits::{TouchEventType, TouchId};
 use servo::servo_config::{opts, pref};
@@ -37,7 +38,6 @@ use servo::servo_url::ServoUrl;
 pub use servo::webrender_api::units::DeviceIntRect;
 use servo::webrender_api::units::DevicePixel;
 use servo::webrender_api::ScrollLocation;
-use servo::webrender_surfman::WebrenderSurfman;
 use servo::{self, gl, Servo, TopLevelBrowsingContextId};
 use servo_media::player::context as MediaPlayerContext;
 use surfman::{Connection, SurfaceType};
@@ -162,7 +162,7 @@ pub trait HostTrait {
 }
 
 pub struct ServoGlue {
-    webrender_surfman: WebrenderSurfman,
+    rendering_context: RenderingContext,
     servo: Servo<ServoWindowCallbacks>,
     batch_mode: bool,
     callbacks: Rc<ServoWindowCallbacks>,
@@ -285,7 +285,7 @@ pub fn init(
             SurfaceType::Generic { size }
         },
     };
-    let webrender_surfman = WebrenderSurfman::create(&connection, &adapter, surface_type)
+    let rendering_context = RenderingContext::create(&connection, &adapter, surface_type)
         .or(Err("Failed to create surface manager"))?;
 
     let window_callbacks = Rc::new(ServoWindowCallbacks {
@@ -294,7 +294,7 @@ pub fn init(
         density: init_opts.density,
         gl_context_pointer: init_opts.gl_context_pointer,
         native_display_pointer: init_opts.native_display_pointer,
-        webrender_surfman: webrender_surfman.clone(),
+        rendering_context: rendering_context.clone(),
     });
 
     let embedder_callbacks = Box::new(ServoEmbedderCallbacks {
@@ -312,7 +312,7 @@ pub fn init(
 
     SERVO.with(|s| {
         let mut servo_glue = ServoGlue {
-            webrender_surfman,
+            rendering_context,
             servo: servo.servo,
             batch_mode: false,
             callbacks: window_callbacks,
@@ -354,8 +354,8 @@ impl ServoGlue {
 
     /// Returns the webrender surface management integration interface.
     /// This provides the embedder access to the current front buffer.
-    pub fn surfman(&self) -> WebrenderSurfman {
+    pub fn surfman(&self) -> RenderingContext {
-        self.webrender_surfman.clone()
+        self.rendering_context.clone()
     }
 
     /// This is the Servo heartbeat. This needs to be called
@@ -863,7 +863,7 @@ struct ServoWindowCallbacks {
     density: f32,
     gl_context_pointer: Option<*const c_void>,
     native_display_pointer: Option<*const c_void>,
-    webrender_surfman: WebrenderSurfman,
+    rendering_context: RenderingContext,
 }
 
 impl EmbedderMethods for ServoEmbedderCallbacks {
@@ -885,8 +885,8 @@ impl EmbedderMethods for ServoEmbedderCallbacks {
 }
 
 impl WindowMethods for ServoWindowCallbacks {
-    fn webrender_surfman(&self) -> WebrenderSurfman {
+    fn rendering_context(&self) -> RenderingContext {
-        self.webrender_surfman.clone()
+        self.rendering_context.clone()
     }
 
     fn set_animation_state(&self, state: AnimationState) {

ports/servoshell/app.rs

@@ -99,21 +99,21 @@ impl App {
 
         if opts::get().minibrowser && window.winit_window().is_some() {
             // Make sure the gl context is made current.
-            let webrender_surfman = window.webrender_surfman();
+            let rendering_context = window.rendering_context();
-            let webrender_gl = match webrender_surfman.connection().gl_api() {
+            let webrender_gl = match rendering_context.connection().gl_api() {
                 GLApi::GL => unsafe {
-                    gl::GlFns::load_with(|s| webrender_surfman.get_proc_address(s))
+                    gl::GlFns::load_with(|s| rendering_context.get_proc_address(s))
                 },
                 GLApi::GLES => unsafe {
-                    gl::GlesFns::load_with(|s| webrender_surfman.get_proc_address(s))
+                    gl::GlesFns::load_with(|s| rendering_context.get_proc_address(s))
                 },
             };
-            webrender_surfman.make_gl_context_current().unwrap();
+            rendering_context.make_gl_context_current().unwrap();
             debug_assert_eq!(webrender_gl.get_error(), gleam::gl::NO_ERROR);
 
             app.minibrowser = Some(
                 Minibrowser::new(
-                    &webrender_surfman,
+                    &rendering_context,
                     &events_loop,
                     window.as_ref(),
                     initial_url.clone(),
@@ -156,7 +156,7 @@ impl App {
             t = now;
             match event {
                 winit::event::Event::NewEvents(winit::event::StartCause::Init) => {
-                    let surfman = window.webrender_surfman();
+                    let surfman = window.rendering_context();
 
                     let xr_discovery = if pref!(dom.webxr.glwindow.enabled) && !opts::get().headless
                     {

ports/servoshell/headed_window.rs

@@ -17,13 +17,13 @@ use servo::compositing::windowing::{
 };
 use servo::embedder_traits::Cursor;
 use servo::keyboard_types::{Key, KeyState, KeyboardEvent};
+use servo::rendering_context::RenderingContext;
 use servo::script_traits::{TouchEventType, WheelDelta, WheelMode};
 use servo::servo_config::{opts, pref};
 use servo::servo_geometry::DeviceIndependentPixel;
 use servo::style_traits::DevicePixel;
 use servo::webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize};
 use servo::webrender_api::ScrollLocation;
-use servo::webrender_surfman::WebrenderSurfman;
 use servo_media::player::context::{GlApi, GlContext as PlayerGLContext, NativeDisplay};
 #[cfg(target_os = "linux")]
 use surfman::platform::generic::multi::connection::NativeConnection;
@@ -47,7 +47,7 @@ use crate::window_trait::{WindowPortsMethods, LINE_HEIGHT};
 
 pub struct Window {
     winit_window: winit::window::Window,
-    webrender_surfman: WebrenderSurfman,
+    rendering_context: RenderingContext,
     screen_size: Size2D<u32, DevicePixel>,
     inner_size: Cell<Size2D<u32, DevicePixel>>,
     toolbar_height: Cell<Length<f32, DeviceIndependentPixel>>,
@@ -136,13 +136,13 @@ impl Window {
             .create_native_widget_from_rwh(window_handle)
             .expect("Failed to create native widget");
         let surface_type = SurfaceType::Widget { native_widget };
-        let webrender_surfman = WebrenderSurfman::create(&connection, &adapter, surface_type)
+        let rendering_context = RenderingContext::create(&connection, &adapter, surface_type)
             .expect("Failed to create WR surfman");
 
         debug!("Created window {:?}", winit_window.id());
         Window {
             winit_window,
-            webrender_surfman,
+            rendering_context,
             event_queue: RefCell::new(vec![]),
             mouse_down_button: Cell::new(None),
             mouse_down_point: Cell::new(Point2D::new(0, 0)),
@@ -477,7 +477,7 @@ impl WindowPortsMethods for Window {
                 let new_size = Size2D::new(width, height);
                 if self.inner_size.get() != new_size {
                     let physical_size = Size2D::new(physical_size.width, physical_size.height);
-                    self.webrender_surfman
+                    self.rendering_context
                         .resize(physical_size.to_i32())
                         .expect("Failed to resize");
                     self.inner_size.set(new_size);
@@ -550,8 +550,8 @@ impl WindowMethods for Window {
         self.animation_state.set(state);
     }
 
-    fn webrender_surfman(&self) -> WebrenderSurfman {
+    fn rendering_context(&self) -> RenderingContext {
-        self.webrender_surfman.clone()
+        self.rendering_context.clone()
     }
 
     fn get_gl_context(&self) -> PlayerGLContext {
@@ -560,7 +560,7 @@ impl WindowMethods for Window {
         }
 
         #[allow(unused_variables)]
-        let native_context = self.webrender_surfman.native_context();
+        let native_context = self.rendering_context.native_context();
 
         #[cfg(target_os = "windows")]
         return PlayerGLContext::Egl(native_context.egl_context as usize);
@@ -591,9 +591,9 @@ impl WindowMethods for Window {
         }
 
         #[allow(unused_variables)]
-        let native_connection = self.webrender_surfman.connection().native_connection();
+        let native_connection = self.rendering_context.connection().native_connection();
         #[allow(unused_variables)]
-        let native_device = self.webrender_surfman.native_device();
+        let native_device = self.rendering_context.native_device();
 
         #[cfg(target_os = "windows")]
         return NativeDisplay::Egl(native_device.egl_display as usize);
@@ -619,8 +619,8 @@ impl WindowMethods for Window {
     }
 
     fn get_gl_api(&self) -> GlApi {
-        let api = self.webrender_surfman.connection().gl_api();
+        let api = self.rendering_context.connection().gl_api();
-        let attributes = self.webrender_surfman.context_attributes();
+        let attributes = self.rendering_context.context_attributes();
         let GLVersion { major, minor } = attributes.version;
         match api {
             GLApi::GL if major >= 3 && minor >= 2 => GlApi::OpenGL3,

ports/servoshell/headless_window.rs

@@ -11,10 +11,10 @@ use euclid::{Length, Point2D, Rotation3D, Scale, Size2D, UnknownUnit, Vector3D};
 use servo::compositing::windowing::{
     AnimationState, EmbedderCoordinates, EmbedderEvent, WindowMethods,
 };
+use servo::rendering_context::RenderingContext;
 use servo::servo_geometry::DeviceIndependentPixel;
 use servo::style_traits::DevicePixel;
 use servo::webrender_api::units::DeviceIntRect;
-use servo::webrender_surfman::WebrenderSurfman;
 use servo_media::player::context as MediaPlayerCtxt;
 use surfman::{Connection, Context, Device, SurfaceType};
 
@@ -22,7 +22,7 @@ use crate::events_loop::WakerEvent;
 use crate::window_trait::WindowPortsMethods;
 
 pub struct Window {
-    webrender_surfman: WebrenderSurfman,
+    rendering_context: RenderingContext,
     animation_state: Cell<AnimationState>,
     fullscreen: Cell<bool>,
     device_pixel_ratio_override: Option<f32>,
@@ -40,11 +40,11 @@ impl Window {
             .expect("Failed to create adapter");
         let size = size.to_untyped().to_i32();
         let surface_type = SurfaceType::Generic { size };
-        let webrender_surfman = WebrenderSurfman::create(&connection, &adapter, surface_type)
+        let rendering_context = RenderingContext::create(&connection, &adapter, surface_type)
             .expect("Failed to create WR surfman");
 
         let window = Window {
-            webrender_surfman,
+            rendering_context,
             animation_state: Cell::new(AnimationState::Idle),
             fullscreen: Cell::new(false),
             device_pixel_ratio_override,
@@ -79,7 +79,7 @@ impl WindowPortsMethods for Window {
 
     fn page_height(&self) -> f32 {
         let height = self
-            .webrender_surfman
+            .rendering_context
             .context_surface_info()
             .unwrap_or(None)
             .map(|info| info.size.height)
@@ -124,7 +124,7 @@ impl WindowMethods for Window {
     fn get_coordinates(&self) -> EmbedderCoordinates {
         let dpr = self.hidpi_factor();
         let size = self
-            .webrender_surfman
+            .rendering_context
             .context_surface_info()
             .unwrap_or(None)
             .map(|info| Size2D::from_untyped(info.size))
@@ -156,8 +156,8 @@ impl WindowMethods for Window {
         MediaPlayerCtxt::GlApi::None
     }
 
-    fn webrender_surfman(&self) -> WebrenderSurfman {
+    fn rendering_context(&self) -> RenderingContext {
-        self.webrender_surfman.clone()
+        self.rendering_context.clone()
     }
 }
 

ports/servoshell/minibrowser.rs

@@ -16,9 +16,9 @@ use glow::NativeFramebuffer;
 use log::{trace, warn};
 use servo::compositing::windowing::EmbedderEvent;
 use servo::msg::constellation_msg::TraversalDirection;
+use servo::rendering_context::RenderingContext;
 use servo::servo_geometry::DeviceIndependentPixel;
 use servo::servo_url::ServoUrl;
-use servo::webrender_surfman::WebrenderSurfman;
 
 use crate::egui_glue::EguiGlow;
 use crate::events_loop::EventsLoop;
@@ -53,13 +53,13 @@ pub enum MinibrowserEvent {
 
 impl Minibrowser {
     pub fn new(
-        webrender_surfman: &WebrenderSurfman,
+        rendering_context: &RenderingContext,
         events_loop: &EventsLoop,
         window: &dyn WindowPortsMethods,
         initial_url: ServoUrl,
     ) -> Self {
         let gl = unsafe {
-            glow::Context::from_loader_function(|s| webrender_surfman.get_proc_address(s))
+            glow::Context::from_loader_function(|s| rendering_context.get_proc_address(s))
         };
 
         // Adapted from https://github.com/emilk/egui/blob/9478e50d012c5138551c38cbee16b07bc1fcf283/crates/egui_glow/examples/pure_glow.rs
@@ -68,7 +68,7 @@ impl Minibrowser {
             .egui_ctx
             .set_pixels_per_point(window.hidpi_factor().get());
 
-        let widget_surface_fbo = match webrender_surfman.context_surface_info() {
+        let widget_surface_fbo = match rendering_context.context_surface_info() {
             Ok(Some(info)) => NonZeroU32::new(info.framebuffer_object).map(NativeFramebuffer),
             Ok(None) => panic!("Failed to get widget surface info from surfman!"),
             Err(error) => panic!("Failed to get widget surface info from surfman! {error:?}"),