Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
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`.
This commit is contained in:
Martin Robinson 2024-01-27 18:58:34 +01:00 • committed by GitHub
parent bbe505e52b
commit bc211f8ff3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 84 additions and 114 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Cargo.lock generated
View file

@ -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"

1
components/canvas/Cargo.toml
View file

@ -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"] }

8
components/canvas/webgl_mode/inprocess.rs
View file

@ -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,

2
components/compositing/Cargo.toml
View file

@ -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]

22
components/compositing/compositor.rs
View file

@ -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()

4
components/compositing/lib.rs
View file

@ -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,
}

6
components/compositing/windowing.rs
View file

@ -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
fn webrender_surfman(&self) -> WebrenderSurfman;
/// Get the RenderingContext instance.
fn rendering_context(&self) -> RenderingContext;
}
pub trait EmbedderMethods {

1
components/gfx/Cargo.toml
View file

@ -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"] }

6
components/gfx/lib.rs
View file

@ -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;
// Text
pub mod rendering_context;
pub mod text;

16
components/webrender_surfman/lib.rs → components/gfx/rendering_context.rs
View file

@ -16,19 +16,19 @@ use surfman::{
SurfaceTexture, SurfaceType,
};
/// A bridge between webrender and surfman
// TODO: move this into a different crate so that script doesn't depend on surfman
/// A Servo rendering context, which holds all of the information needed
/// 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(

1
components/servo/Cargo.toml
View file

@ -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" }

19
components/servo/lib.rs
View file

@ -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() {
GLApi::GL => unsafe { gl::GlFns::load_with(|s| webrender_surfman.get_proc_address(s)) },
let webrender_gl = match rendering_context.connection().gl_api() {
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,
},

1
components/shared/compositing/Cargo.toml
View file

@ -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" }

15
components/webrender_surfman/Cargo.toml
View file

@ -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 }

20
ports/jniapi/src/simpleservo.rs
View file

@ -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) {

14
ports/servoshell/app.rs
View file

@ -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
{

24
ports/servoshell/headed_window.rs
View file

@ -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,

16
ports/servoshell/headless_window.rs
View file

@ -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()
}
}

8
ports/servoshell/minibrowser.rs
View file

@ -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:?}"),