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`.

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 {
-        self.webrender_surfman.clone()
+    pub fn surfman(&self) -> RenderingContext {
+        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 {
-        self.webrender_surfman.clone()
+    fn rendering_context(&self) -> RenderingContext {
+        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 webrender_gl = match webrender_surfman.connection().gl_api() {
+            let rendering_context = window.rendering_context();
+            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 {
-        self.webrender_surfman.clone()
+    fn rendering_context(&self) -> RenderingContext {
+        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 attributes = self.webrender_surfman.context_attributes();
+        let api = self.rendering_context.connection().gl_api();
+        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 {
-        self.webrender_surfman.clone()
+    fn rendering_context(&self) -> RenderingContext {
+        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:?}"),