Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 13:40:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Try to use WebRender types more

Browse source 
The newer versions of WebRender move types around between `webrender` and
`webrender_api` and this will reduce the churn during the upgrade.
This commit is contained in:
Martin Robinson 2023-07-10 15:54:39 +02:00
parent 1543912589
commit 3230162fd0
No known key found for this signature in database
GPG key ID: D56AA4FA55EFE6F8
39 changed files with 330 additions and 327 deletions
Download patch file Download diff file Expand all files Collapse all files

19
components/canvas/canvas_data.rs
View file

@ -27,7 +27,8 @@ use std::sync::{Arc, Mutex};
use style::properties::style_structs::Font as FontStyleStruct; use style::properties::style_structs::Font as FontStyleStruct;
use style::values::computed::font; use style::values::computed::font;
use style_traits::values::ToCss; use style_traits::values::ToCss;
use webrender_api::units::RectExt as RectExt_; use webrender_api::units::{DeviceIntSize, RectExt as RectExt_};
use webrender_api::{ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat, ImageKey};
/// The canvas data stores a state machine for the current status of /// The canvas data stores a state machine for the current status of
/// the path data and any relevant transformations that are /// the path data and any relevant transformations that are
@ -405,11 +406,11 @@ pub struct CanvasData<'a> {
state: CanvasPaintState<'a>, state: CanvasPaintState<'a>,
saved_states: Vec<CanvasPaintState<'a>>, saved_states: Vec<CanvasPaintState<'a>>,
webrender_api: Box<dyn WebrenderApi>, webrender_api: Box<dyn WebrenderApi>,
image_key: Option<webrender_api::ImageKey>, image_key: Option<ImageKey>,
/// An old webrender image key that can be deleted when the next epoch ends. /// An old webrender image key that can be deleted when the next epoch ends.
old_image_key: Option<webrender_api::ImageKey>, old_image_key: Option<ImageKey>,
/// An old webrender image key that can be deleted when the current epoch ends. /// An old webrender image key that can be deleted when the current epoch ends.
very_old_image_key: Option<webrender_api::ImageKey>, very_old_image_key: Option<ImageKey>,
font_cache_thread: Mutex<FontCacheThread>, font_cache_thread: Mutex<FontCacheThread>,
} }
@ -1107,15 +1108,15 @@ impl<'a> CanvasData<'a> {
pub fn send_data(&mut self, chan: IpcSender<CanvasImageData>) { pub fn send_data(&mut self, chan: IpcSender<CanvasImageData>) {
let size = self.drawtarget.get_size(); let size = self.drawtarget.get_size();
let descriptor = webrender_api::ImageDescriptor { let descriptor = ImageDescriptor {
size: webrender_api::units::DeviceIntSize::new(size.width, size.height), size: DeviceIntSize::new(size.width, size.height),
stride: None, stride: None,
format: webrender_api::ImageFormat::BGRA8, format: ImageFormat::BGRA8,
offset: 0, offset: 0,
flags: webrender_api::ImageDescriptorFlags::empty(), flags: ImageDescriptorFlags::empty(),
}; };
let data = self.drawtarget.snapshot_data_owned(); let data = self.drawtarget.snapshot_data_owned();
let data = webrender_api::ImageData::Raw(Arc::new(data)); let data = ImageData::Raw(Arc::new(data));
let mut updates = vec![]; let mut updates = vec![];

2
components/canvas/canvas_paint_thread.rs
View file

@ -27,7 +27,7 @@ pub enum ImageUpdate {
} }
pub trait WebrenderApi { pub trait WebrenderApi {
fn generate_key(&self) -> Result<webrender_api::ImageKey, ()>; fn generate_key(&self) -> Result<ImageKey, ()>;
fn update_images(&self, updates: Vec<ImageUpdate>); fn update_images(&self, updates: Vec<ImageUpdate>);
fn clone(&self) -> Box<dyn WebrenderApi>; fn clone(&self) -> Box<dyn WebrenderApi>;
} }

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

@ -16,6 +16,7 @@ use surfman::SurfaceTexture;
use surfman_chains::SwapChains; use surfman_chains::SwapChains;
use surfman_chains_api::SwapChainAPI; use surfman_chains_api::SwapChainAPI;
use surfman_chains_api::SwapChainsAPI; use surfman_chains_api::SwapChainsAPI;
use webrender_api::{DocumentId, RenderApiSender};
use webrender_surfman::WebrenderSurfman; use webrender_surfman::WebrenderSurfman;
use webrender_traits::{ use webrender_traits::{
WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageSource, WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageSource,
@ -33,8 +34,8 @@ impl WebGLComm {
/// Creates a new `WebGLComm` object. /// Creates a new `WebGLComm` object.
pub fn new( pub fn new(
surfman: WebrenderSurfman, surfman: WebrenderSurfman,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: RenderApiSender,
webrender_doc: webrender_api::DocumentId, webrender_doc: DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
api_type: GlType, api_type: GlType,
) -> WebGLComm { ) -> WebGLComm {

78
components/canvas/webgl_thread.rs
View file

@ -69,6 +69,11 @@ use surfman::SurfaceInfo;
use surfman::SurfaceType; use surfman::SurfaceType;
use surfman_chains::SwapChains; use surfman_chains::SwapChains;
use surfman_chains_api::SwapChainsAPI; use surfman_chains_api::SwapChainsAPI;
use webrender_api::{
units::DeviceIntSize, DirtyRect, DocumentId, ExternalImageData, ExternalImageId,
ExternalImageType, ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat, ImageKey,
RenderApi, RenderApiSender, TextureTarget, Transaction,
};
use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType}; use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
use webxr::SurfmanGL as WebXRSurfman; use webxr::SurfmanGL as WebXRSurfman;
use webxr_api::ContextId as WebXRContextId; use webxr_api::ContextId as WebXRContextId;
@ -229,9 +234,9 @@ impl Default for GLState {
pub(crate) struct WebGLThread { pub(crate) struct WebGLThread {
/// The GPU device. /// The GPU device.
device: Device, device: Device,
/// Channel used to generate/update or delete `webrender_api::ImageKey`s. /// Channel used to generate/update or delete `ImageKey`s.
webrender_api: webrender_api::RenderApi, webrender_api: RenderApi,
webrender_doc: webrender_api::DocumentId, webrender_doc: DocumentId,
/// Map of live WebGLContexts. /// Map of live WebGLContexts.
contexts: FnvHashMap<WebGLContextId, GLContextData>, contexts: FnvHashMap<WebGLContextId, GLContextData>,
/// Cached information for WebGLContexts. /// Cached information for WebGLContexts.
@ -255,8 +260,8 @@ pub(crate) struct WebGLThread {
/// The data required to initialize an instance of the WebGLThread type. /// The data required to initialize an instance of the WebGLThread type.
pub(crate) struct WebGLThreadInit { pub(crate) struct WebGLThreadInit {
pub webrender_api_sender: webrender_api::RenderApiSender, pub webrender_api_sender: RenderApiSender,
pub webrender_doc: webrender_api::DocumentId, pub webrender_doc: DocumentId,
pub external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, pub external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
pub sender: WebGLSender<WebGLMsg>, pub sender: WebGLSender<WebGLMsg>,
pub receiver: WebGLReceiver<WebGLMsg>, pub receiver: WebGLReceiver<WebGLMsg>,
@ -744,7 +749,7 @@ impl WebGLThread {
fn remove_webgl_context(&mut self, context_id: WebGLContextId) { fn remove_webgl_context(&mut self, context_id: WebGLContextId) {
// Release webrender image keys. // Release webrender image keys.
if let Some(info) = self.cached_context_info.remove(&context_id) { if let Some(info) = self.cached_context_info.remove(&context_id) {
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.delete_image(info.image_key); txn.delete_image(info.image_key);
self.webrender_api.send_transaction(self.webrender_doc, txn) self.webrender_api.send_transaction(self.webrender_doc, txn)
} }
@ -923,66 +928,63 @@ impl WebGLThread {
/// Creates a `webrender_api::ImageKey` that uses shared textures. /// Creates a `webrender_api::ImageKey` that uses shared textures.
fn create_wr_external_image( fn create_wr_external_image(
webrender_api: &mut webrender_api::RenderApi, webrender_api: &mut RenderApi,
webrender_doc: webrender_api::DocumentId, webrender_doc: DocumentId,
size: Size2D<i32>, size: Size2D<i32>,
alpha: bool, alpha: bool,
context_id: WebGLContextId, context_id: WebGLContextId,
target: webrender_api::TextureTarget, target: TextureTarget,
) -> webrender_api::ImageKey { ) -> ImageKey {
let descriptor = Self::image_descriptor(size, alpha); let descriptor = Self::image_descriptor(size, alpha);
let data = Self::external_image_data(context_id, target); let data = Self::external_image_data(context_id, target);
let image_key = webrender_api.generate_image_key(); let image_key = webrender_api.generate_image_key();
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.add_image(image_key, descriptor, data, None); txn.add_image(image_key, descriptor, data, None);
webrender_api.send_transaction(webrender_doc, txn); webrender_api.send_transaction(webrender_doc, txn);
image_key image_key
} }
/// Updates a `webrender_api::ImageKey` that uses shared textures. /// Updates a `ImageKey` that uses shared textures.
fn update_wr_external_image( fn update_wr_external_image(
webrender_api: &mut webrender_api::RenderApi, webrender_api: &mut RenderApi,
webrender_doc: webrender_api::DocumentId, webrender_doc: DocumentId,
size: Size2D<i32>, size: Size2D<i32>,
alpha: bool, alpha: bool,
context_id: WebGLContextId, context_id: WebGLContextId,
image_key: webrender_api::ImageKey, image_key: ImageKey,
target: webrender_api::TextureTarget, target: TextureTarget,
) { ) {
let descriptor = Self::image_descriptor(size, alpha); let descriptor = Self::image_descriptor(size, alpha);
let data = Self::external_image_data(context_id, target); let data = Self::external_image_data(context_id, target);
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.update_image(image_key, descriptor, data, &webrender_api::DirtyRect::All); txn.update_image(image_key, descriptor, data, &DirtyRect::All);
webrender_api.send_transaction(webrender_doc, txn); webrender_api.send_transaction(webrender_doc, txn);
} }
/// Helper function to create a `webrender_api::ImageDescriptor`. /// Helper function to create a `ImageDescriptor`.
fn image_descriptor(size: Size2D<i32>, alpha: bool) -> webrender_api::ImageDescriptor { fn image_descriptor(size: Size2D<i32>, alpha: bool) -> ImageDescriptor {
let mut flags = webrender_api::ImageDescriptorFlags::empty(); let mut flags = ImageDescriptorFlags::empty();
flags.set(webrender_api::ImageDescriptorFlags::IS_OPAQUE, !alpha); flags.set(ImageDescriptorFlags::IS_OPAQUE, !alpha);
webrender_api::ImageDescriptor { ImageDescriptor {
size: webrender_api::units::DeviceIntSize::new(size.width, size.height), size: DeviceIntSize::new(size.width, size.height),
stride: None, stride: None,
format: webrender_api::ImageFormat::BGRA8, format: ImageFormat::BGRA8,
offset: 0, offset: 0,
flags, flags,
} }
} }
/// Helper function to create a `webrender_api::ImageData::External` instance. /// Helper function to create a `ImageData::External` instance.
fn external_image_data( fn external_image_data(context_id: WebGLContextId, target: TextureTarget) -> ImageData {
context_id: WebGLContextId, let data = ExternalImageData {
target: webrender_api::TextureTarget, id: ExternalImageId(context_id.0 as u64),
) -> webrender_api::ImageData {
let data = webrender_api::ExternalImageData {
id: webrender_api::ExternalImageId(context_id.0 as u64),
channel_index: 0, channel_index: 0,
image_type: webrender_api::ExternalImageType::TextureHandle(target), image_type: ExternalImageType::TextureHandle(target),
}; };
webrender_api::ImageData::External(data) ImageData::External(data)
} }
/// Gets the GLSL Version supported by a GLContext. /// Gets the GLSL Version supported by a GLContext.
@ -1006,14 +1008,14 @@ impl WebGLThread {
/// Helper struct to store cached WebGLContext information. /// Helper struct to store cached WebGLContext information.
struct WebGLContextInfo { struct WebGLContextInfo {
/// Currently used WebRender image key. /// Currently used WebRender image key.
image_key: webrender_api::ImageKey, image_key: ImageKey,
} }
// TODO(pcwalton): Add `GL_TEXTURE_EXTERNAL_OES`? // TODO(pcwalton): Add `GL_TEXTURE_EXTERNAL_OES`?
fn current_wr_texture_target(device: &Device) -> webrender_api::TextureTarget { fn current_wr_texture_target(device: &Device) -> TextureTarget {
match device.surface_gl_texture_target() { match device.surface_gl_texture_target() {
gl::TEXTURE_RECTANGLE => webrender_api::TextureTarget::Rect, gl::TEXTURE_RECTANGLE => TextureTarget::Rect,
_ => webrender_api::TextureTarget::Default, _ => TextureTarget::Default,
} }
} }

3
components/canvas_traits/canvas.rs
View file

@ -9,6 +9,7 @@ use serde_bytes::ByteBuf;
use std::default::Default; use std::default::Default;
use std::str::FromStr; use std::str::FromStr;
use style::properties::style_structs::Font as FontStyleStruct; use style::properties::style_structs::Font as FontStyleStruct;
use webrender_api::ImageKey;
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub enum FillRule { pub enum FillRule {
@ -30,7 +31,7 @@ pub enum CanvasMsg {
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CanvasImageData { pub struct CanvasImageData {
pub image_key: webrender_api::ImageKey, pub image_key: ImageKey,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]

64
components/compositing/compositor.rs
View file

@ -51,7 +51,11 @@ use time::{now, precise_time_ns, precise_time_s};
use webrender_api::units::{ use webrender_api::units::{
DeviceIntPoint, DeviceIntSize, DevicePoint, LayoutPoint, LayoutVector2D, WorldPoint, DeviceIntPoint, DeviceIntSize, DevicePoint, LayoutPoint, LayoutVector2D, WorldPoint,
}; };
use webrender_api::{self, ExternalScrollId, HitTestFlags, ScrollClamping, ScrollLocation}; use webrender_api::{
self, BuiltDisplayList, CaptureBits, DirtyRect, DocumentId, Epoch as WebRenderEpoch,
ExternalScrollId, HitTestFlags, PipelineId as WebRenderPipelineId, RenderApi, ScrollClamping,
ScrollLocation, Transaction, ZoomFactor,
};
use webrender_surfman::WebrenderSurfman; use webrender_surfman::WebrenderSurfman;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@ -74,7 +78,7 @@ trait ConvertPipelineIdFromWebRender {
fn from_webrender(&self) -> PipelineId; fn from_webrender(&self) -> PipelineId;
} }
impl ConvertPipelineIdFromWebRender for webrender_api::PipelineId { impl ConvertPipelineIdFromWebRender for WebRenderPipelineId {
fn from_webrender(&self) -> PipelineId { fn from_webrender(&self) -> PipelineId {
PipelineId { PipelineId {
namespace_id: PipelineNamespaceId(self.0), namespace_id: PipelineNamespaceId(self.0),
@ -182,10 +186,10 @@ pub struct IOCompositor<Window: WindowMethods + ?Sized> {
webrender: webrender::Renderer, webrender: webrender::Renderer,
/// The active webrender document. /// The active webrender document.
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
/// The webrender interface, if enabled. /// The webrender interface, if enabled.
webrender_api: webrender_api::RenderApi, webrender_api: RenderApi,
/// The surfman instance that webrender targets /// The surfman instance that webrender targets
webrender_surfman: WebrenderSurfman, webrender_surfman: WebrenderSurfman,
@ -628,9 +632,9 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
match msg { match msg {
WebrenderMsg::Layout(script_traits::WebrenderMsg::SendInitialTransaction(pipeline)) => { WebrenderMsg::Layout(script_traits::WebrenderMsg::SendInitialTransaction(pipeline)) => {
self.waiting_on_pending_frame = true; self.waiting_on_pending_frame = true;
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.set_display_list( txn.set_display_list(
webrender_api::Epoch(0), WebRenderEpoch(0),
None, None,
Default::default(), Default::default(),
(pipeline, Default::default(), Default::default()), (pipeline, Default::default(), Default::default()),
@ -647,7 +651,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
)) => { )) => {
self.waiting_for_results_of_scroll = true; self.waiting_for_results_of_scroll = true;
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.scroll_node_with_id(point, scroll_id, clamping); txn.scroll_node_with_id(point, scroll_id, clamping);
txn.generate_frame(); txn.generate_frame();
self.webrender_api self.webrender_api
@ -668,7 +672,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
details.hit_test_items = display_list_info.hit_test_info; details.hit_test_items = display_list_info.hit_test_info;
details.install_new_scroll_tree(display_list_info.scroll_tree); details.install_new_scroll_tree(display_list_info.scroll_tree);
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.set_display_list( txn.set_display_list(
display_list_info.epoch, display_list_info.epoch,
None, None,
@ -676,10 +680,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
( (
pipeline_id, pipeline_id,
content_size, content_size,
webrender_api::BuiltDisplayList::from_data( BuiltDisplayList::from_data(data, display_list_descriptor),
data,
display_list_descriptor,
),
), ),
true, true,
); );
@ -718,7 +719,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}, },
WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateImages(updates)) => { WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateImages(updates)) => {
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
for update in updates { for update in updates {
match update { match update {
script_traits::SerializedImageUpdate::AddImage(key, desc, data) => { script_traits::SerializedImageUpdate::AddImage(key, desc, data) => {
@ -732,12 +733,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}, },
script_traits::SerializedImageUpdate::UpdateImage(key, desc, data) => { script_traits::SerializedImageUpdate::UpdateImage(key, desc, data) => {
match data.to_image_data() { match data.to_image_data() {
Ok(data) => txn.update_image( Ok(data) => txn.update_image(key, desc, data, &DirtyRect::All),
key,
desc,
data,
&webrender_api::DirtyRect::All,
),
Err(e) => warn!("error when sending image data: {:?}", e), Err(e) => warn!("error when sending image data: {:?}", e),
} }
}, },
@ -748,7 +744,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}, },
WebrenderMsg::Net(net_traits::WebrenderImageMsg::AddImage(key, desc, data)) => { WebrenderMsg::Net(net_traits::WebrenderImageMsg::AddImage(key, desc, data)) => {
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.add_image(key, desc, data, None); txn.add_image(key, desc, data, None);
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -756,7 +752,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
WebrenderMsg::Font(WebrenderFontMsg::AddFontInstance(font_key, size, sender)) => { WebrenderMsg::Font(WebrenderFontMsg::AddFontInstance(font_key, size, sender)) => {
let key = self.webrender_api.generate_font_instance_key(); let key = self.webrender_api.generate_font_instance_key();
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.add_font_instance(key, font_key, size, None, None, Vec::new()); txn.add_font_instance(key, font_key, size, None, None, Vec::new());
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -765,7 +761,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
WebrenderMsg::Font(WebrenderFontMsg::AddFont(data, sender)) => { WebrenderMsg::Font(WebrenderFontMsg::AddFont(data, sender)) => {
let font_key = self.webrender_api.generate_font_key(); let font_key = self.webrender_api.generate_font_key();
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
match data { match data {
FontData::Raw(bytes) => txn.add_raw_font(font_key, bytes, 0), FontData::Raw(bytes) => txn.add_raw_font(font_key, bytes, 0),
FontData::Native(native_font) => txn.add_native_font(font_key, native_font), FontData::Native(native_font) => txn.add_native_font(font_key, native_font),
@ -780,14 +776,14 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}, },
WebrenderMsg::Canvas(WebrenderCanvasMsg::UpdateImages(updates)) => { WebrenderMsg::Canvas(WebrenderCanvasMsg::UpdateImages(updates)) => {
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
for update in updates { for update in updates {
match update { match update {
ImageUpdate::Add(key, descriptor, data) => { ImageUpdate::Add(key, descriptor, data) => {
txn.add_image(key, descriptor, data, None) txn.add_image(key, descriptor, data, None)
}, },
ImageUpdate::Update(key, descriptor, data) => { ImageUpdate::Update(key, descriptor, data) => {
txn.update_image(key, descriptor, data, &webrender_api::DirtyRect::All) txn.update_image(key, descriptor, data, &DirtyRect::All)
}, },
ImageUpdate::Delete(key) => txn.delete_image(key), ImageUpdate::Delete(key) => txn.delete_image(key),
} }
@ -866,7 +862,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}; };
let pipeline_id = frame_tree.pipeline.id.to_webrender(); let pipeline_id = frame_tree.pipeline.id.to_webrender();
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.set_root_pipeline(pipeline_id); txn.set_root_pipeline(pipeline_id);
txn.generate_frame(); txn.generate_frame();
self.webrender_api self.webrender_api
@ -1026,7 +1022,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
&self, &self,
point: WorldPoint, point: WorldPoint,
flags: HitTestFlags, flags: HitTestFlags,
pipeline_id: Option<webrender_api::PipelineId>, pipeline_id: Option<WebRenderPipelineId>,
) -> Vec<CompositorHitTestResult> { ) -> Vec<CompositorHitTestResult> {
let root_pipeline_id = match self.root_pipeline.id { let root_pipeline_id = match self.root_pipeline.id {
Some(root_pipeline_id) => root_pipeline_id, Some(root_pipeline_id) => root_pipeline_id,
@ -1271,7 +1267,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
}; };
let cursor = (combined_event.cursor.to_f32() / self.scale).to_untyped(); let cursor = (combined_event.cursor.to_f32() / self.scale).to_untyped();
let cursor = WorldPoint::from_untyped(cursor); let cursor = WorldPoint::from_untyped(cursor);
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
let result = match self.hit_test_at_point(cursor) { let result = match self.hit_test_at_point(cursor) {
Some(result) => result, Some(result) => result,
@ -1298,7 +1294,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
if combined_event.magnification != 1.0 { if combined_event.magnification != 1.0 {
let old_zoom = self.pinch_zoom_level(); let old_zoom = self.pinch_zoom_level();
self.set_pinch_zoom_level(old_zoom * combined_event.magnification); self.set_pinch_zoom_level(old_zoom * combined_event.magnification);
txn.set_pinch_zoom(webrender_api::ZoomFactor::new(self.pinch_zoom_level())); txn.set_pinch_zoom(ZoomFactor::new(self.pinch_zoom_level()));
} }
txn.generate_frame(); txn.generate_frame();
self.webrender_api self.webrender_api
@ -1390,9 +1386,9 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
} }
fn update_page_zoom_for_webrender(&mut self) { fn update_page_zoom_for_webrender(&mut self) {
let page_zoom = webrender_api::ZoomFactor::new(self.page_zoom.get()); let page_zoom = ZoomFactor::new(self.page_zoom.get());
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.set_page_zoom(page_zoom); txn.set_page_zoom(page_zoom);
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -1464,7 +1460,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
let mut pipeline_epochs = HashMap::new(); let mut pipeline_epochs = HashMap::new();
for (id, _) in &self.pipeline_details { for (id, _) in &self.pipeline_details {
let webrender_pipeline_id = id.to_webrender(); let webrender_pipeline_id = id.to_webrender();
if let Some(webrender_api::Epoch(epoch)) = self if let Some(WebRenderEpoch(epoch)) = self
.webrender .webrender
.current_epoch(self.webrender_document, webrender_pipeline_id) .current_epoch(self.webrender_document, webrender_pipeline_id)
{ {
@ -1613,7 +1609,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
// For each pending paint metrics pipeline id // For each pending paint metrics pipeline id
for (id, pending_epoch) in &self.pending_paint_metrics { for (id, pending_epoch) in &self.pending_paint_metrics {
// we get the last painted frame id from webrender // we get the last painted frame id from webrender
if let Some(webrender_api::Epoch(epoch)) = self if let Some(WebRenderEpoch(epoch)) = self
.webrender .webrender
.current_epoch(self.webrender_document, id.to_webrender()) .current_epoch(self.webrender_document, id.to_webrender())
{ {
@ -1877,7 +1873,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
flags.toggle(flag); flags.toggle(flag);
self.webrender.set_debug_flags(flags); self.webrender.set_debug_flags(flags);
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.generate_frame(); txn.generate_frame();
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -1909,7 +1905,7 @@ impl<Window: WindowMethods + ?Sized> IOCompositor<Window> {
&revision_file_path &revision_file_path
); );
self.webrender_api self.webrender_api
.save_capture(capture_path, webrender_api::CaptureBits::all()); .save_capture(capture_path, CaptureBits::all());
match File::create(revision_file_path) { match File::create(revision_file_path) {
Ok(mut file) => { Ok(mut file) => {

16
components/compositing/compositor_thread.rs
View file

@ -20,8 +20,8 @@ use script_traits::{AnimationState, EventResult, MouseButton, MouseEventType};
use std::fmt::{Debug, Error, Formatter}; use std::fmt::{Debug, Error, Formatter};
use std::rc::Rc; use std::rc::Rc;
use style_traits::CSSPixel; use style_traits::CSSPixel;
use webrender_api;
use webrender_api::units::{DeviceIntPoint, DeviceIntSize}; use webrender_api::units::{DeviceIntPoint, DeviceIntSize};
use webrender_api::{self, DocumentId, FontInstanceKey, FontKey, ImageKey, RenderApi};
use webrender_surfman::WebrenderSurfman; use webrender_surfman::WebrenderSurfman;
/// Sends messages to the compositor. /// Sends messages to the compositor.
@ -124,16 +124,12 @@ pub enum Msg {
} }
pub enum WebrenderFontMsg { pub enum WebrenderFontMsg {
AddFontInstance( AddFontInstance(FontKey, f32, Sender<FontInstanceKey>),
webrender_api::FontKey, AddFont(gfx_traits::FontData, Sender<FontKey>),
f32,
Sender<webrender_api::FontInstanceKey>,
),
AddFont(gfx_traits::FontData, Sender<webrender_api::FontKey>),
} }
pub enum WebrenderCanvasMsg { pub enum WebrenderCanvasMsg {
GenerateKey(Sender<webrender_api::ImageKey>), GenerateKey(Sender<ImageKey>),
UpdateImages(Vec<ImageUpdate>), UpdateImages(Vec<ImageUpdate>),
} }
@ -186,8 +182,8 @@ pub struct InitialCompositorState {
pub mem_profiler_chan: mem::ProfilerChan, pub mem_profiler_chan: mem::ProfilerChan,
/// Instance of webrender API /// Instance of webrender API
pub webrender: webrender::Renderer, pub webrender: webrender::Renderer,
pub webrender_document: webrender_api::DocumentId, pub webrender_document: DocumentId,
pub webrender_api: webrender_api::RenderApi, pub webrender_api: RenderApi,
pub webrender_surfman: WebrenderSurfman, pub webrender_surfman: WebrenderSurfman,
pub webrender_gl: Rc<dyn gleam::gl::Gl>, pub webrender_gl: Rc<dyn gleam::gl::Gl>,
pub webxr_main_thread: webxr::MainThreadRegistry, pub webxr_main_thread: webxr::MainThreadRegistry,

3
components/compositing/windowing.rs
View file

@ -16,8 +16,7 @@ use std::fmt::{Debug, Error, Formatter};
use std::time::Duration; use std::time::Duration;
use style_traits::DevicePixel; use style_traits::DevicePixel;
use webrender_api::units::DevicePoint; use webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePoint};
use webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize};
use webrender_api::ScrollLocation; use webrender_api::ScrollLocation;
use webrender_surfman::WebrenderSurfman; use webrender_surfman::WebrenderSurfman;

9
components/constellation/constellation.rs
View file

@ -178,6 +178,7 @@ use std::sync::{Arc, Mutex};
use std::thread; use std::thread;
use style_traits::CSSPixel; use style_traits::CSSPixel;
use webgpu::{self, WebGPU, WebGPURequest}; use webgpu::{self, WebGPU, WebGPURequest};
use webrender_api::{DocumentId, RenderApi, RenderApiSender};
use webrender_traits::WebrenderExternalImageRegistry; use webrender_traits::WebrenderExternalImageRegistry;
type PendingApprovalNavigations = HashMap<PipelineId, (LoadData, HistoryEntryReplacement)>; type PendingApprovalNavigations = HashMap<PipelineId, (LoadData, HistoryEntryReplacement)>;
@ -221,7 +222,7 @@ struct MessagePortInfo {
/// Webrender related objects required by WebGPU threads /// Webrender related objects required by WebGPU threads
struct WebrenderWGPU { struct WebrenderWGPU {
/// Webrender API. /// Webrender API.
webrender_api: webrender_api::RenderApi, webrender_api: RenderApi,
/// List of Webrender external images /// List of Webrender external images
webrender_external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, webrender_external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@ -394,7 +395,7 @@ pub struct Constellation<Message, LTF, STF, SWF> {
timer_scheduler: TimerScheduler, timer_scheduler: TimerScheduler,
/// A single WebRender document the constellation operates on. /// A single WebRender document the constellation operates on.
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
/// Webrender related objects required by WebGPU threads /// Webrender related objects required by WebGPU threads
webrender_wgpu: WebrenderWGPU, webrender_wgpu: WebrenderWGPU,
@ -543,10 +544,10 @@ pub struct InitialConstellationState {
pub mem_profiler_chan: mem::ProfilerChan, pub mem_profiler_chan: mem::ProfilerChan,
/// Webrender document ID. /// Webrender document ID.
pub webrender_document: webrender_api::DocumentId, pub webrender_document: DocumentId,
/// Webrender API. /// Webrender API.
pub webrender_api_sender: webrender_api::RenderApiSender, pub webrender_api_sender: RenderApiSender,
/// Webrender external images /// Webrender external images
pub webrender_external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, pub webrender_external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,

5
components/constellation/pipeline.rs
View file

@ -48,6 +48,7 @@ use std::collections::{HashMap, HashSet};
use std::rc::Rc; use std::rc::Rc;
use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicBool;
use std::sync::Arc; use std::sync::Arc;
use webrender_api::DocumentId;
/// A `Pipeline` is the constellation's view of a `Document`. Each pipeline has an /// A `Pipeline` is the constellation's view of a `Document`. Each pipeline has an
/// event loop (executed by a script thread) and a layout thread. A script thread /// event loop (executed by a script thread) and a layout thread. A script thread
@ -190,7 +191,7 @@ pub struct InitialPipelineState {
pub webrender_api_sender: script_traits::WebrenderIpcSender, pub webrender_api_sender: script_traits::WebrenderIpcSender,
/// The ID of the document processed by this script thread. /// The ID of the document processed by this script thread.
pub webrender_document: webrender_api::DocumentId, pub webrender_document: DocumentId,
/// A channel to the WebGL thread. /// A channel to the WebGL thread.
pub webgl_chan: Option<WebGLPipeline>, pub webgl_chan: Option<WebGLPipeline>,
@ -514,7 +515,7 @@ pub struct UnprivilegedPipelineContent {
pipeline_namespace_id: PipelineNamespaceId, pipeline_namespace_id: PipelineNamespaceId,
webrender_api_sender: script_traits::WebrenderIpcSender, webrender_api_sender: script_traits::WebrenderIpcSender,
webrender_image_api_sender: net_traits::WebrenderIpcSender, webrender_image_api_sender: net_traits::WebrenderIpcSender,
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
webgl_chan: Option<WebGLPipeline>, webgl_chan: Option<WebGLPipeline>,
webxr_registry: webxr_api::Registry, webxr_registry: webxr_api::Registry,
player_context: WindowGLContext, player_context: WindowGLContext,

5
components/gfx/font.rs
View file

@ -27,6 +27,7 @@ use style::computed_values::{font_stretch, font_style, font_variant_caps, font_w
use style::properties::style_structs::Font as FontStyleStruct; use style::properties::style_structs::Font as FontStyleStruct;
use style::values::computed::font::{GenericFontFamily, SingleFontFamily}; use style::values::computed::font::{GenericFontFamily, SingleFontFamily};
use unicode_script::Script; use unicode_script::Script;
use webrender_api::FontInstanceKey;
macro_rules! ot_tag { macro_rules! ot_tag {
($t1:expr, $t2:expr, $t3:expr, $t4:expr) => { ($t1:expr, $t2:expr, $t3:expr, $t4:expr) => {
@ -145,7 +146,7 @@ pub struct Font {
shaper: Option<Shaper>, shaper: Option<Shaper>,
shape_cache: RefCell<HashMap<ShapeCacheEntry, Arc<GlyphStore>>>, shape_cache: RefCell<HashMap<ShapeCacheEntry, Arc<GlyphStore>>>,
glyph_advance_cache: RefCell<HashMap<u32, FractionalPixel>>, glyph_advance_cache: RefCell<HashMap<u32, FractionalPixel>>,
pub font_key: webrender_api::FontInstanceKey, pub font_key: FontInstanceKey,
} }
impl Font { impl Font {
@ -153,7 +154,7 @@ impl Font {
handle: FontHandle, handle: FontHandle,
descriptor: FontDescriptor, descriptor: FontDescriptor,
actual_pt_size: Au, actual_pt_size: Au,
font_key: webrender_api::FontInstanceKey, font_key: FontInstanceKey,
) -> Font { ) -> Font {
let metrics = handle.metrics(); let metrics = handle.metrics();

21
components/gfx/font_cache_thread.rs
View file

@ -25,6 +25,7 @@ use std::sync::{Arc, Mutex};
use std::{f32, fmt, mem, thread}; use std::{f32, fmt, mem, thread};
use style::font_face::{EffectiveSources, Source}; use style::font_face::{EffectiveSources, Source};
use style::values::computed::font::FamilyName; use style::values::computed::font::FamilyName;
use webrender_api::{FontInstanceKey, FontKey};
/// A list of font templates that make up a given font family. /// A list of font templates that make up a given font family.
pub struct FontTemplates { pub struct FontTemplates {
@ -34,13 +35,13 @@ pub struct FontTemplates {
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub struct FontTemplateInfo { pub struct FontTemplateInfo {
pub font_template: Arc<FontTemplateData>, pub font_template: Arc<FontTemplateData>,
pub font_key: webrender_api::FontKey, pub font_key: FontKey,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub struct SerializedFontTemplateInfo { pub struct SerializedFontTemplateInfo {
pub serialized_font_template: SerializedFontTemplate, pub serialized_font_template: SerializedFontTemplate,
pub font_key: webrender_api::FontKey, pub font_key: FontKey,
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
@ -128,11 +129,7 @@ pub enum Command {
FontFamilyDescriptor, FontFamilyDescriptor,
IpcSender<Reply>, IpcSender<Reply>,
), ),
GetFontInstance( GetFontInstance(FontKey, Au, IpcSender<FontInstanceKey>),
webrender_api::FontKey,
Au,
IpcSender<webrender_api::FontInstanceKey>,
),
AddWebFont(LowercaseString, EffectiveSources, IpcSender<()>), AddWebFont(LowercaseString, EffectiveSources, IpcSender<()>),
AddDownloadedWebFont(LowercaseString, ServoUrl, Vec<u8>, IpcSender<()>), AddDownloadedWebFont(LowercaseString, ServoUrl, Vec<u8>, IpcSender<()>),
Exit(IpcSender<()>), Exit(IpcSender<()>),
@ -156,8 +153,8 @@ struct FontCache {
font_context: FontContextHandle, font_context: FontContextHandle,
core_resource_thread: CoreResourceThread, core_resource_thread: CoreResourceThread,
webrender_api: Box<dyn WebrenderApi>, webrender_api: Box<dyn WebrenderApi>,
webrender_fonts: HashMap<Atom, webrender_api::FontKey>, webrender_fonts: HashMap<Atom, FontKey>,
font_instances: HashMap<(webrender_api::FontKey, Au), webrender_api::FontInstanceKey>, font_instances: HashMap<(FontKey, Au), FontInstanceKey>,
} }
fn populate_generic_fonts() -> HashMap<FontFamilyName, LowercaseString> { fn populate_generic_fonts() -> HashMap<FontFamilyName, LowercaseString> {
@ -536,11 +533,7 @@ impl FontCacheThread {
} }
impl FontSource for FontCacheThread { impl FontSource for FontCacheThread {
fn get_font_instance( fn get_font_instance(&mut self, key: FontKey, size: Au) -> FontInstanceKey {
&mut self,
key: webrender_api::FontKey,
size: Au,
) -> webrender_api::FontInstanceKey {
let (response_chan, response_port) = ipc::channel().expect("failed to create IPC channel"); let (response_chan, response_port) = ipc::channel().expect("failed to create IPC channel");
self.chan self.chan
.send(Command::GetFontInstance(key, size, response_chan)) .send(Command::GetFontInstance(key, size, response_chan))

7
components/gfx/font_context.rs
View file

@ -21,6 +21,7 @@ use std::rc::Rc;
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use style::computed_values::font_variant_caps::T as FontVariantCaps; use style::computed_values::font_variant_caps::T as FontVariantCaps;
use style::properties::style_structs::Font as FontStyleStruct; use style::properties::style_structs::Font as FontStyleStruct;
use webrender_api::{FontInstanceKey, FontKey};
static SMALL_CAPS_SCALE_FACTOR: f32 = 0.8; // Matches FireFox (see gfxFont.h) static SMALL_CAPS_SCALE_FACTOR: f32 = 0.8; // Matches FireFox (see gfxFont.h)
@ -29,11 +30,7 @@ static SMALL_CAPS_SCALE_FACTOR: f32 = 0.8; // Matches FireFox (see gfxFont.h)
static FONT_CACHE_EPOCH: AtomicUsize = AtomicUsize::new(0); static FONT_CACHE_EPOCH: AtomicUsize = AtomicUsize::new(0);
pub trait FontSource { pub trait FontSource {
fn get_font_instance( fn get_font_instance(&mut self, key: FontKey, size: Au) -> FontInstanceKey;
&mut self,
key: webrender_api::FontKey,
size: Au,
) -> webrender_api::FontInstanceKey;
fn font_template( fn font_template(
&mut self, &mut self,

11
components/gfx/tests/font_context.rs
View file

@ -24,6 +24,7 @@ use style::values::computed::font::{
}; };
use style::values::computed::font::{FontStretch, FontWeight, SingleFontFamily}; use style::values::computed::font::{FontStretch, FontWeight, SingleFontFamily};
use style::values::generics::font::FontStyle; use style::values::generics::font::FontStyle;
use webrender_api::{FontInstanceKey, FontKey, IdNamespace};
struct TestFontSource { struct TestFontSource {
handle: FontContextHandle, handle: FontContextHandle,
@ -68,12 +69,8 @@ impl TestFontSource {
} }
impl FontSource for TestFontSource { impl FontSource for TestFontSource {
fn get_font_instance( fn get_font_instance(&mut self, _key: FontKey, _size: Au) -> FontInstanceKey {
&mut self, FontInstanceKey(IdNamespace(0), 0)
_key: webrender_api::FontKey,
_size: Au,
) -> webrender_api::FontInstanceKey {
webrender_api::FontInstanceKey(webrender_api::IdNamespace(0), 0)
} }
fn font_template( fn font_template(
@ -89,7 +86,7 @@ impl FontSource for TestFontSource {
.and_then(|family| family.find_font_for_style(&template_descriptor, handle)) .and_then(|family| family.find_font_for_style(&template_descriptor, handle))
.map(|template| FontTemplateInfo { .map(|template| FontTemplateInfo {
font_template: template, font_template: template,
font_key: webrender_api::FontKey(webrender_api::IdNamespace(0), 0), font_key: FontKey(IdNamespace(0), 0),
}) })
} }
} }

3
components/gfx/text/text_run.rs
View file

@ -14,6 +14,7 @@ use std::slice::Iter;
use std::sync::Arc; use std::sync::Arc;
use style::str::char_is_whitespace; use style::str::char_is_whitespace;
use unicode_bidi as bidi; use unicode_bidi as bidi;
use webrender_api::FontInstanceKey;
use xi_unicode::LineBreakLeafIter; use xi_unicode::LineBreakLeafIter;
thread_local! { thread_local! {
@ -29,7 +30,7 @@ pub struct TextRun {
pub font_template: Arc<FontTemplateData>, pub font_template: Arc<FontTemplateData>,
pub actual_pt_size: Au, pub actual_pt_size: Au,
pub font_metrics: FontMetrics, pub font_metrics: FontMetrics,
pub font_key: webrender_api::FontInstanceKey, pub font_key: FontInstanceKey,
/// The glyph runs that make up this text run. /// The glyph runs that make up this text run.
pub glyphs: Arc<Vec<GlyphRun>>, pub glyphs: Arc<Vec<GlyphRun>>,
pub bidi_level: bidi::Level, pub bidi_level: bidi::Level,

17
components/gfx_traits/lib.rs
View file

@ -17,6 +17,7 @@ pub mod print_tree;
use range::RangeIndex; use range::RangeIndex;
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use webrender_api::{Epoch as WebRenderEpoch, FontInstanceKey, FontKey, NativeFontHandle};
/// A newtype struct for denoting the age of messages; prevents race conditions. /// A newtype struct for denoting the age of messages; prevents race conditions.
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)] #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
@ -28,9 +29,9 @@ impl Epoch {
} }
} }
impl Into<webrender_api::Epoch> for Epoch { impl Into<WebRenderEpoch> for Epoch {
fn into(self) -> webrender_api::Epoch { fn into(self) -> WebRenderEpoch {
webrender_api::Epoch(self.0) WebRenderEpoch(self.0)
} }
} }
@ -112,14 +113,10 @@ pub fn node_id_from_scroll_id(id: usize) -> Option<usize> {
pub enum FontData { pub enum FontData {
Raw(Vec<u8>), Raw(Vec<u8>),
Native(webrender_api::NativeFontHandle), Native(NativeFontHandle),
} }
pub trait WebrenderApi { pub trait WebrenderApi {
fn add_font_instance( fn add_font_instance(&self, font_key: FontKey, size: f32) -> FontInstanceKey;
&self, fn add_font(&self, data: FontData) -> FontKey;
font_key: webrender_api::FontKey,
size: f32,
) -> webrender_api::FontInstanceKey;
fn add_font(&self, data: FontData) -> webrender_api::FontKey;
} }

2
components/layout/display_list/webrender_helpers.rs
View file

@ -258,7 +258,7 @@ impl DisplayItem {
let stacking_context = &item.stacking_context; let stacking_context = &item.stacking_context;
debug_assert_eq!(stacking_context.context_type, StackingContextType::Real); debug_assert_eq!(stacking_context.context_type, StackingContextType::Real);
//let mut info = webrender_api::LayoutPrimitiveInfo::new(stacking_context.bounds); //let mut info = LayoutPrimitiveInfo::new(stacking_context.bounds);
let mut bounds = stacking_context.bounds; let mut bounds = stacking_context.bounds;
let spatial_id = let spatial_id =
if let Some(frame_index) = stacking_context.established_reference_frame { if let Some(frame_index) = stacking_context.established_reference_frame {

6
components/layout/fragment.rs
View file

@ -64,8 +64,8 @@ use style::values::computed::counters::ContentItem;
use style::values::computed::{Length, Size, VerticalAlign}; use style::values::computed::{Length, Size, VerticalAlign};
use style::values::generics::box_::{Perspective, VerticalAlignKeyword}; use style::values::generics::box_::{Perspective, VerticalAlignKeyword};
use style::values::generics::transform; use style::values::generics::transform;
use webrender_api;
use webrender_api::units::LayoutTransform; use webrender_api::units::LayoutTransform;
use webrender_api::{self, ImageKey};
// From gfxFontConstants.h in Firefox. // From gfxFontConstants.h in Firefox.
static FONT_SUBSCRIPT_OFFSET_RATIO: f32 = 0.20; static FONT_SUBSCRIPT_OFFSET_RATIO: f32 = 0.20;
@ -336,9 +336,9 @@ impl InlineAbsoluteFragmentInfo {
#[derive(Clone)] #[derive(Clone)]
pub enum CanvasFragmentSource { pub enum CanvasFragmentSource {
WebGL(webrender_api::ImageKey), WebGL(ImageKey),
Image(Option<Arc<Mutex<IpcSender<CanvasMsg>>>>), Image(Option<Arc<Mutex<IpcSender<CanvasMsg>>>>),
WebGPU(webrender_api::ImageKey), WebGPU(ImageKey),
} }
#[derive(Clone)] #[derive(Clone)]

6
components/layout/sequential.rs
View file

@ -20,7 +20,7 @@ use euclid::default::{Point2D, Rect, Size2D, Vector2D};
use servo_config::opts; use servo_config::opts;
use style::servo::restyle_damage::ServoRestyleDamage; use style::servo::restyle_damage::ServoRestyleDamage;
use webrender_api::units::LayoutPoint; use webrender_api::units::LayoutPoint;
use webrender_api::PropertyBinding; use webrender_api::{ColorF, PropertyBinding, RectangleDisplayItem};
pub fn resolve_generated_content(root: &mut dyn Flow, layout_context: &LayoutContext) { pub fn resolve_generated_content(root: &mut dyn Flow, layout_context: &LayoutContext) {
ResolveGeneratedContent::new(&layout_context).traverse(root, 0); ResolveGeneratedContent::new(&layout_context).traverse(root, 0);
@ -75,7 +75,7 @@ pub fn reflow(root: &mut dyn Flow, layout_context: &LayoutContext, relayout_mode
pub fn build_display_list_for_subtree<'a>( pub fn build_display_list_for_subtree<'a>(
flow_root: &mut dyn Flow, flow_root: &mut dyn Flow,
layout_context: &'a LayoutContext, layout_context: &'a LayoutContext,
background_color: webrender_api::ColorF, background_color: ColorF,
client_size: Size2D<Au>, client_size: Size2D<Au>,
) -> DisplayListBuildState<'a> { ) -> DisplayListBuildState<'a> {
let mut state = StackingContextCollectionState::new(layout_context.id); let mut state = StackingContextCollectionState::new(layout_context.id);
@ -94,7 +94,7 @@ pub fn build_display_list_for_subtree<'a>(
); );
state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new( state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new(
base, base,
webrender_api::RectangleDisplayItem { RectangleDisplayItem {
color: PropertyBinding::Value(background_color), color: PropertyBinding::Value(background_color),
common: items::empty_common_item_properties(), common: items::empty_common_item_properties(),
bounds: bounds.to_layout(), bounds: bounds.to_layout(),

90
components/layout_2020/display_list/conversions.rs
View file

@ -8,7 +8,7 @@ use style::computed_values::text_decoration_style::T as ComputedTextDecorationSt
use style::computed_values::transform_style::T as ComputedTransformStyle; use style::computed_values::transform_style::T as ComputedTransformStyle;
use style::values::computed::Filter as ComputedFilter; use style::values::computed::Filter as ComputedFilter;
use style::values::computed::Length; use style::values::computed::Length;
use webrender_api as wr; use webrender_api::{units, FilterOp, LineStyle, MixBlendMode, TransformStyle};
pub trait ToWebRender { pub trait ToWebRender {
type Type; type Type;
@ -16,18 +16,18 @@ pub trait ToWebRender {
} }
impl ToWebRender for ComputedFilter { impl ToWebRender for ComputedFilter {
type Type = wr::FilterOp; type Type = FilterOp;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
match *self { match *self {
ComputedFilter::Blur(radius) => wr::FilterOp::Blur(radius.px()), ComputedFilter::Blur(radius) => FilterOp::Blur(radius.px()),
ComputedFilter::Brightness(amount) => wr::FilterOp::Brightness(amount.0), ComputedFilter::Brightness(amount) => FilterOp::Brightness(amount.0),
ComputedFilter::Contrast(amount) => wr::FilterOp::Contrast(amount.0), ComputedFilter::Contrast(amount) => FilterOp::Contrast(amount.0),
ComputedFilter::Grayscale(amount) => wr::FilterOp::Grayscale(amount.0), ComputedFilter::Grayscale(amount) => FilterOp::Grayscale(amount.0),
ComputedFilter::HueRotate(angle) => wr::FilterOp::HueRotate(angle.radians()), ComputedFilter::HueRotate(angle) => FilterOp::HueRotate(angle.radians()),
ComputedFilter::Invert(amount) => wr::FilterOp::Invert(amount.0), ComputedFilter::Invert(amount) => FilterOp::Invert(amount.0),
ComputedFilter::Opacity(amount) => wr::FilterOp::Opacity(amount.0.into(), amount.0), ComputedFilter::Opacity(amount) => FilterOp::Opacity(amount.0.into(), amount.0),
ComputedFilter::Saturate(amount) => wr::FilterOp::Saturate(amount.0), ComputedFilter::Saturate(amount) => FilterOp::Saturate(amount.0),
ComputedFilter::Sepia(amount) => wr::FilterOp::Sepia(amount.0), ComputedFilter::Sepia(amount) => FilterOp::Sepia(amount.0),
// Statically check that DropShadow is impossible. // Statically check that DropShadow is impossible.
ComputedFilter::DropShadow(ref shadow) => match *shadow {}, ComputedFilter::DropShadow(ref shadow) => match *shadow {},
// Statically check that Url is impossible. // Statically check that Url is impossible.
@ -36,64 +36,64 @@ impl ToWebRender for ComputedFilter {
} }
} }
impl ToWebRender for ComputedMixBlendMode { impl ToWebRender for ComputedMixBlendMode {
type Type = wr::MixBlendMode; type Type = MixBlendMode;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
match *self { match *self {
ComputedMixBlendMode::Normal => wr::MixBlendMode::Normal, ComputedMixBlendMode::Normal => MixBlendMode::Normal,
ComputedMixBlendMode::Multiply => wr::MixBlendMode::Multiply, ComputedMixBlendMode::Multiply => MixBlendMode::Multiply,
ComputedMixBlendMode::Screen => wr::MixBlendMode::Screen, ComputedMixBlendMode::Screen => MixBlendMode::Screen,
ComputedMixBlendMode::Overlay => wr::MixBlendMode::Overlay, ComputedMixBlendMode::Overlay => MixBlendMode::Overlay,
ComputedMixBlendMode::Darken => wr::MixBlendMode::Darken, ComputedMixBlendMode::Darken => MixBlendMode::Darken,
ComputedMixBlendMode::Lighten => wr::MixBlendMode::Lighten, ComputedMixBlendMode::Lighten => MixBlendMode::Lighten,
ComputedMixBlendMode::ColorDodge => wr::MixBlendMode::ColorDodge, ComputedMixBlendMode::ColorDodge => MixBlendMode::ColorDodge,
ComputedMixBlendMode::ColorBurn => wr::MixBlendMode::ColorBurn, ComputedMixBlendMode::ColorBurn => MixBlendMode::ColorBurn,
ComputedMixBlendMode::HardLight => wr::MixBlendMode::HardLight, ComputedMixBlendMode::HardLight => MixBlendMode::HardLight,
ComputedMixBlendMode::SoftLight => wr::MixBlendMode::SoftLight, ComputedMixBlendMode::SoftLight => MixBlendMode::SoftLight,
ComputedMixBlendMode::Difference => wr::MixBlendMode::Difference, ComputedMixBlendMode::Difference => MixBlendMode::Difference,
ComputedMixBlendMode::Exclusion => wr::MixBlendMode::Exclusion, ComputedMixBlendMode::Exclusion => MixBlendMode::Exclusion,
ComputedMixBlendMode::Hue => wr::MixBlendMode::Hue, ComputedMixBlendMode::Hue => MixBlendMode::Hue,
ComputedMixBlendMode::Saturation => wr::MixBlendMode::Saturation, ComputedMixBlendMode::Saturation => MixBlendMode::Saturation,
ComputedMixBlendMode::Color => wr::MixBlendMode::Color, ComputedMixBlendMode::Color => MixBlendMode::Color,
ComputedMixBlendMode::Luminosity => wr::MixBlendMode::Luminosity, ComputedMixBlendMode::Luminosity => MixBlendMode::Luminosity,
} }
} }
} }
impl ToWebRender for ComputedTransformStyle { impl ToWebRender for ComputedTransformStyle {
type Type = wr::TransformStyle; type Type = TransformStyle;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
match *self { match *self {
ComputedTransformStyle::Flat => wr::TransformStyle::Flat, ComputedTransformStyle::Flat => TransformStyle::Flat,
ComputedTransformStyle::Preserve3d => wr::TransformStyle::Preserve3D, ComputedTransformStyle::Preserve3d => TransformStyle::Preserve3D,
} }
} }
} }
impl ToWebRender for PhysicalPoint<Length> { impl ToWebRender for PhysicalPoint<Length> {
type Type = webrender_api::units::LayoutPoint; type Type = units::LayoutPoint;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
webrender_api::units::LayoutPoint::new(self.x.px(), self.y.px()) units::LayoutPoint::new(self.x.px(), self.y.px())
} }
} }
impl ToWebRender for PhysicalSize<Length> { impl ToWebRender for PhysicalSize<Length> {
type Type = webrender_api::units::LayoutSize; type Type = units::LayoutSize;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
webrender_api::units::LayoutSize::new(self.width.px(), self.height.px()) units::LayoutSize::new(self.width.px(), self.height.px())
} }
} }
impl ToWebRender for PhysicalRect<Length> { impl ToWebRender for PhysicalRect<Length> {
type Type = webrender_api::units::LayoutRect; type Type = units::LayoutRect;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
webrender_api::units::LayoutRect::new(self.origin.to_webrender(), self.size.to_webrender()) units::LayoutRect::new(self.origin.to_webrender(), self.size.to_webrender())
} }
} }
impl ToWebRender for PhysicalSides<Length> { impl ToWebRender for PhysicalSides<Length> {
type Type = webrender_api::units::LayoutSideOffsets; type Type = units::LayoutSideOffsets;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
webrender_api::units::LayoutSideOffsets::new( units::LayoutSideOffsets::new(
self.top.px(), self.top.px(),
self.right.px(), self.right.px(),
self.bottom.px(), self.bottom.px(),
@ -103,14 +103,14 @@ impl ToWebRender for PhysicalSides<Length> {
} }
impl ToWebRender for ComputedTextDecorationStyle { impl ToWebRender for ComputedTextDecorationStyle {
type Type = webrender_api::LineStyle; type Type = LineStyle;
fn to_webrender(&self) -> Self::Type { fn to_webrender(&self) -> Self::Type {
match *self { match *self {
ComputedTextDecorationStyle::Solid => wr::LineStyle::Solid, ComputedTextDecorationStyle::Solid => LineStyle::Solid,
ComputedTextDecorationStyle::Dotted => wr::LineStyle::Dotted, ComputedTextDecorationStyle::Dotted => LineStyle::Dotted,
ComputedTextDecorationStyle::Dashed => wr::LineStyle::Dashed, ComputedTextDecorationStyle::Dashed => LineStyle::Dashed,
ComputedTextDecorationStyle::Wavy => wr::LineStyle::Wavy, ComputedTextDecorationStyle::Wavy => LineStyle::Wavy,
_ => wr::LineStyle::Solid, _ => LineStyle::Solid,
} }
} }
} }

2
components/layout_2020/display_list/gradient.rs
View file

@ -66,7 +66,7 @@ pub(super) fn build_linear(
) { ) {
use style::values::specified::position::HorizontalPositionKeyword::*; use style::values::specified::position::HorizontalPositionKeyword::*;
use style::values::specified::position::VerticalPositionKeyword::*; use style::values::specified::position::VerticalPositionKeyword::*;
use webrender_api::units::LayoutVector2D as Vec2; use units::LayoutVector2D as Vec2;
let gradient_box = layer.tile_size; let gradient_box = layer.tile_size;
// A vector of length 1.0 in the direction of the gradient line // A vector of length 1.0 in the direction of the gradient line

2
components/layout_2020/display_list/mod.rs
View file

@ -42,7 +42,7 @@ pub struct WebRenderImageInfo {
pub key: Option<wr::ImageKey>, pub key: Option<wr::ImageKey>,
} }
// `webrender_api::display_item::ItemTag` is private // webrender's `ItemTag` is private.
type ItemTag = (u64, u16); type ItemTag = (u64, u16);
type HitInfo = Option<ItemTag>; type HitInfo = Option<ItemTag>;

5
components/layout_2020/fragment_tree/fragment_tree.rs
View file

@ -14,6 +14,7 @@ use gfx_traits::print_tree::PrintTree;
use style::animation::AnimationSetKey; use style::animation::AnimationSetKey;
use style::dom::OpaqueNode; use style::dom::OpaqueNode;
use style::values::computed::Length; use style::values::computed::Length;
use webrender_api::units;
#[derive(Serialize)] #[derive(Serialize)]
pub struct FragmentTree { pub struct FragmentTree {
@ -61,8 +62,8 @@ impl FragmentTree {
} }
} }
pub fn scrollable_overflow(&self) -> webrender_api::units::LayoutSize { pub fn scrollable_overflow(&self) -> units::LayoutSize {
webrender_api::units::LayoutSize::from_untyped(Size2D::new( units::LayoutSize::from_untyped(Size2D::new(
self.scrollable_overflow.size.width.px(), self.scrollable_overflow.size.width.px(),
self.scrollable_overflow.size.height.px(), self.scrollable_overflow.size.height.px(),
)) ))

4
components/layout_2020/query.rs
View file

@ -34,14 +34,14 @@ use style::values::generics::text::LineHeight;
use style_traits::CSSPixel; use style_traits::CSSPixel;
use style_traits::ToCss; use style_traits::ToCss;
use webrender_api::units::LayoutPixel; use webrender_api::units::LayoutPixel;
use webrender_api::ExternalScrollId; use webrender_api::{DisplayListBuilder, ExternalScrollId};
/// Mutable data belonging to the LayoutThread. /// Mutable data belonging to the LayoutThread.
/// ///
/// This needs to be protected by a mutex so we can do fast RPCs. /// This needs to be protected by a mutex so we can do fast RPCs.
pub struct LayoutThreadData { pub struct LayoutThreadData {
/// The root stacking context. /// The root stacking context.
pub display_list: Option<webrender_api::DisplayListBuilder>, pub display_list: Option<DisplayListBuilder>,
/// A queued response for the union of the content boxes of a node. /// A queued response for the union of the content boxes of a node.
pub content_box_response: Option<Rect<Au>>, pub content_box_response: Option<Rect<Au>>,

21
components/layout_thread/lib.rs
View file

@ -117,6 +117,7 @@ use style::traversal_flags::TraversalFlags;
use style_traits::CSSPixel; use style_traits::CSSPixel;
use style_traits::DevicePixel; use style_traits::DevicePixel;
use style_traits::SpeculativePainter; use style_traits::SpeculativePainter;
use webrender_api::{units, ColorF, HitTestFlags, ScrollClamping};
/// Information needed by the layout thread. /// Information needed by the layout thread.
pub struct LayoutThread { pub struct LayoutThread {
@ -1060,7 +1061,7 @@ impl LayoutThread {
debug!("Layout done!"); debug!("Layout done!");
let viewport_size = webrender_api::units::LayoutSize::new( let viewport_size = units::LayoutSize::new(
self.viewport_size.width.to_f32_px(), self.viewport_size.width.to_f32_px(),
self.viewport_size.height.to_f32_px(), self.viewport_size.height.to_f32_px(),
); );
@ -1471,15 +1472,15 @@ impl LayoutThread {
&QueryMsg::StyleQuery => {}, &QueryMsg::StyleQuery => {},
&QueryMsg::NodesFromPointQuery(client_point, ref reflow_goal) => { &QueryMsg::NodesFromPointQuery(client_point, ref reflow_goal) => {
let mut flags = match reflow_goal { let mut flags = match reflow_goal {
&NodesFromPointQueryType::Topmost => webrender_api::HitTestFlags::empty(), &NodesFromPointQueryType::Topmost => HitTestFlags::empty(),
&NodesFromPointQueryType::All => webrender_api::HitTestFlags::FIND_ALL, &NodesFromPointQueryType::All => HitTestFlags::FIND_ALL,
}; };
// The point we get is not relative to the entire WebRender scene, but to this // The point we get is not relative to the entire WebRender scene, but to this
// particular pipeline, so we need to tell WebRender about that. // particular pipeline, so we need to tell WebRender about that.
flags.insert(webrender_api::HitTestFlags::POINT_RELATIVE_TO_PIPELINE_VIEWPORT); flags.insert(HitTestFlags::POINT_RELATIVE_TO_PIPELINE_VIEWPORT);
let client_point = webrender_api::units::WorldPoint::from_untyped(client_point); let client_point = units::WorldPoint::from_untyped(client_point);
let results = self.webrender_api.hit_test( let results = self.webrender_api.hit_test(
Some(self.id.to_webrender()), Some(self.id.to_webrender()),
client_point, client_point,
@ -1516,9 +1517,9 @@ impl LayoutThread {
let point = Point2D::new(-state.scroll_offset.x, -state.scroll_offset.y); let point = Point2D::new(-state.scroll_offset.x, -state.scroll_offset.y);
self.webrender_api.send_scroll_node( self.webrender_api.send_scroll_node(
webrender_api::units::LayoutPoint::from_untyped(point), units::LayoutPoint::from_untyped(point),
state.scroll_id, state.scroll_id,
webrender_api::ScrollClamping::ToContentBounds, ScrollClamping::ToContentBounds,
); );
} }
@ -1769,8 +1770,8 @@ impl ProfilerMetadataFactory for LayoutThread {
// clearing the frame buffer to white. This ensures that setting a background // clearing the frame buffer to white. This ensures that setting a background
// color on an iframe element, while the iframe content itself has a default // color on an iframe element, while the iframe content itself has a default
// transparent background color is handled correctly. // transparent background color is handled correctly.
fn get_root_flow_background_color(flow: &mut dyn Flow) -> webrender_api::ColorF { fn get_root_flow_background_color(flow: &mut dyn Flow) -> ColorF {
let transparent = webrender_api::ColorF { let transparent = ColorF {
r: 0.0, r: 0.0,
g: 0.0, g: 0.0,
b: 0.0, b: 0.0,
@ -1797,7 +1798,7 @@ fn get_root_flow_background_color(flow: &mut dyn Flow) -> webrender_api::ColorF
.get_background() .get_background()
.background_color, .background_color,
); );
webrender_api::ColorF::new( ColorF::new(
color.red_f32(), color.red_f32(),
color.green_f32(), color.green_f32(),
color.blue_f32(), color.blue_f32(),

15
components/layout_thread_2020/lib.rs
View file

@ -100,6 +100,7 @@ use style::traversal_flags::TraversalFlags;
use style_traits::CSSPixel; use style_traits::CSSPixel;
use style_traits::DevicePixel; use style_traits::DevicePixel;
use style_traits::SpeculativePainter; use style_traits::SpeculativePainter;
use webrender_api::{units, HitTestFlags, ScrollClamping};
/// Information needed by the layout thread. /// Information needed by the layout thread.
pub struct LayoutThread { pub struct LayoutThread {
@ -1136,15 +1137,15 @@ impl LayoutThread {
&QueryMsg::StyleQuery => {}, &QueryMsg::StyleQuery => {},
&QueryMsg::NodesFromPointQuery(client_point, ref reflow_goal) => { &QueryMsg::NodesFromPointQuery(client_point, ref reflow_goal) => {
let mut flags = match reflow_goal { let mut flags = match reflow_goal {
&NodesFromPointQueryType::Topmost => webrender_api::HitTestFlags::empty(), &NodesFromPointQueryType::Topmost => HitTestFlags::empty(),
&NodesFromPointQueryType::All => webrender_api::HitTestFlags::FIND_ALL, &NodesFromPointQueryType::All => HitTestFlags::FIND_ALL,
}; };
// The point we get is not relative to the entire WebRender scene, but to this // The point we get is not relative to the entire WebRender scene, but to this
// particular pipeline, so we need to tell WebRender about that. // particular pipeline, so we need to tell WebRender about that.
flags.insert(webrender_api::HitTestFlags::POINT_RELATIVE_TO_PIPELINE_VIEWPORT); flags.insert(HitTestFlags::POINT_RELATIVE_TO_PIPELINE_VIEWPORT);
let client_point = webrender_api::units::WorldPoint::from_untyped(client_point); let client_point = units::WorldPoint::from_untyped(client_point);
let results = self.webrender_api.hit_test( let results = self.webrender_api.hit_test(
Some(self.id.to_webrender()), Some(self.id.to_webrender()),
client_point, client_point,
@ -1178,9 +1179,9 @@ impl LayoutThread {
let point = Point2D::new(-state.scroll_offset.x, -state.scroll_offset.y); let point = Point2D::new(-state.scroll_offset.x, -state.scroll_offset.y);
self.webrender_api.send_scroll_node( self.webrender_api.send_scroll_node(
webrender_api::units::LayoutPoint::from_untyped(point), units::LayoutPoint::from_untyped(point),
state.scroll_id, state.scroll_id,
webrender_api::ScrollClamping::ToContentBounds, ScrollClamping::ToContentBounds,
); );
} }
@ -1248,7 +1249,7 @@ impl LayoutThread {
epoch.next(); epoch.next();
self.epoch.set(epoch); self.epoch.set(epoch);
let viewport_size = webrender_api::units::LayoutSize::from_untyped(Size2D::new( let viewport_size = units::LayoutSize::from_untyped(Size2D::new(
self.viewport_size.width.to_f32_px(), self.viewport_size.width.to_f32_px(),
self.viewport_size.height.to_f32_px(), self.viewport_size.height.to_f32_px(),
)); ));

48
components/malloc_size_of/lib.rs
View file

@ -58,6 +58,12 @@ use std::os::raw::c_void;
#[cfg(feature = "servo")] #[cfg(feature = "servo")]
use uuid::Uuid; use uuid::Uuid;
use void::Void; use void::Void;
use webrender_api::{
BorderRadius, BorderStyle, BoxShadowClipMode, ColorF, ComplexClipRegion, ExtendMode,
ExternalScrollId, FilterOp, FontInstanceKey, GlyphInstance, GradientStop, ImageKey,
ImageRendering, LineStyle, MixBlendMode, NinePatchBorder, NormalBorder, RepeatMode,
ScrollSensitivity, StickyOffsetBounds, TransformStyle,
};
/// A C function that takes a pointer to a heap allocation and returns its size. /// A C function that takes a pointer to a heap allocation and returns its size.
type VoidPtrToSizeFn = unsafe extern "C" fn(ptr: *const c_void) -> usize; type VoidPtrToSizeFn = unsafe extern "C" fn(ptr: *const c_void) -> usize;
@ -800,47 +806,47 @@ impl MallocSizeOf for url::Host {
} }
} }
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::BorderRadius); malloc_size_of_is_0!(BorderRadius);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::BorderStyle); malloc_size_of_is_0!(BorderStyle);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::BoxShadowClipMode); malloc_size_of_is_0!(BoxShadowClipMode);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ColorF); malloc_size_of_is_0!(ColorF);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ComplexClipRegion); malloc_size_of_is_0!(ComplexClipRegion);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ExtendMode); malloc_size_of_is_0!(ExtendMode);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::FilterOp); malloc_size_of_is_0!(FilterOp);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ExternalScrollId); malloc_size_of_is_0!(ExternalScrollId);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::FontInstanceKey); malloc_size_of_is_0!(FontInstanceKey);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::GradientStop); malloc_size_of_is_0!(GradientStop);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::GlyphInstance); malloc_size_of_is_0!(GlyphInstance);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::NinePatchBorder); malloc_size_of_is_0!(NinePatchBorder);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ImageKey); malloc_size_of_is_0!(ImageKey);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ImageRendering); malloc_size_of_is_0!(ImageRendering);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::LineStyle); malloc_size_of_is_0!(LineStyle);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::MixBlendMode); malloc_size_of_is_0!(MixBlendMode);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::NormalBorder); malloc_size_of_is_0!(NormalBorder);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::RepeatMode); malloc_size_of_is_0!(RepeatMode);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::ScrollSensitivity); malloc_size_of_is_0!(ScrollSensitivity);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::StickyOffsetBounds); malloc_size_of_is_0!(StickyOffsetBounds);
#[cfg(feature = "webrender_api")] #[cfg(feature = "webrender_api")]
malloc_size_of_is_0!(webrender_api::TransformStyle); malloc_size_of_is_0!(TransformStyle);
#[cfg(feature = "servo")] #[cfg(feature = "servo")]
impl MallocSizeOf for keyboard_types::Key { impl MallocSizeOf for keyboard_types::Key {

3
components/media/media_thread.rs
View file

@ -9,6 +9,7 @@ use crate::{GLPlayerMsg, GLPlayerMsgForward};
use fnv::FnvHashMap; use fnv::FnvHashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::thread; use std::thread;
use webrender_api::ExternalImageId;
use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType}; use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
/// A GLPlayerThread manages the life cycle and message demultiplexing of /// A GLPlayerThread manages the life cycle and message demultiplexing of
@ -69,7 +70,7 @@ impl GLPlayerThread {
self.external_images self.external_images
.lock() .lock()
.unwrap() .unwrap()
.remove(&webrender_api::ExternalImageId(id)); .remove(&ExternalImageId(id));
if self.players.remove(&id).is_none() { if self.players.remove(&id).is_none() {
warn!("Tried to remove an unknown player"); warn!("Tried to remove an unknown player");
} }

12
components/msg/constellation_msg.rs
View file

@ -13,6 +13,8 @@ use std::mem;
use std::num::NonZeroU32; use std::num::NonZeroU32;
use std::sync::Arc; use std::sync::Arc;
use std::time::Duration; use std::time::Duration;
use webrender_api::ExternalScrollId;
use webrender_api::PipelineId as WebRenderPipelineId;
macro_rules! namespace_id_method { macro_rules! namespace_id_method {
($func_name:ident, $func_return_data_type:ident, $self:ident, $index_name:ident) => { ($func_name:ident, $func_return_data_type:ident, $self:ident, $index_name:ident) => {
@ -206,15 +208,15 @@ impl PipelineId {
}) })
} }
pub fn to_webrender(&self) -> webrender_api::PipelineId { pub fn to_webrender(&self) -> WebRenderPipelineId {
let PipelineNamespaceId(namespace_id) = self.namespace_id; let PipelineNamespaceId(namespace_id) = self.namespace_id;
let PipelineIndex(index) = self.index; let PipelineIndex(index) = self.index;
webrender_api::PipelineId(namespace_id, index.get()) WebRenderPipelineId(namespace_id, index.get())
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
pub fn from_webrender(pipeline: webrender_api::PipelineId) -> PipelineId { pub fn from_webrender(pipeline: WebRenderPipelineId) -> PipelineId {
let webrender_api::PipelineId(namespace_id, index) = pipeline; let WebRenderPipelineId(namespace_id, index) = pipeline;
unsafe { unsafe {
PipelineId { PipelineId {
namespace_id: PipelineNamespaceId(namespace_id), namespace_id: PipelineNamespaceId(namespace_id),
@ -224,7 +226,7 @@ impl PipelineId {
} }
pub fn root_scroll_id(&self) -> webrender_api::ExternalScrollId { pub fn root_scroll_id(&self) -> webrender_api::ExternalScrollId {
webrender_api::ExternalScrollId(0, self.to_webrender()) ExternalScrollId(0, self.to_webrender())
} }
} }

11
components/net/image_cache.rs
View file

@ -22,8 +22,9 @@ use std::collections::HashMap;
use std::mem; use std::mem;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::thread; use std::thread;
use webrender_api::units::DeviceIntSize; use webrender_api::{
use webrender_api::ImageDescriptorFlags; units::DeviceIntSize, ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat,
};
/// ///
/// TODO(gw): Remaining work on image cache: /// TODO(gw): Remaining work on image cache:
@ -77,14 +78,14 @@ fn set_webrender_image_key(webrender_api: &WebrenderIpcSender, image: &mut Image
}; };
let mut flags = ImageDescriptorFlags::ALLOW_MIPMAPS; let mut flags = ImageDescriptorFlags::ALLOW_MIPMAPS;
flags.set(ImageDescriptorFlags::IS_OPAQUE, is_opaque); flags.set(ImageDescriptorFlags::IS_OPAQUE, is_opaque);
let descriptor = webrender_api::ImageDescriptor { let descriptor = ImageDescriptor {
size: DeviceIntSize::new(image.width as i32, image.height as i32), size: DeviceIntSize::new(image.width as i32, image.height as i32),
stride: None, stride: None,
format: webrender_api::ImageFormat::BGRA8, format: ImageFormat::BGRA8,
offset: 0, offset: 0,
flags, flags,
}; };
let data = webrender_api::ImageData::new(bytes); let data = ImageData::new(bytes);
let image_key = webrender_api.generate_image_key(); let image_key = webrender_api.generate_image_key();
webrender_api.add_image(image_key, descriptor, data); webrender_api.add_image(image_key, descriptor, data);
image.id = Some(image_key); image.id = Some(image_key);

3
components/net_traits/image/base.rs
View file

@ -7,6 +7,7 @@ use image::ImageFormat;
use ipc_channel::ipc::IpcSharedMemory; use ipc_channel::ipc::IpcSharedMemory;
use pixels::PixelFormat; use pixels::PixelFormat;
use std::fmt; use std::fmt;
use webrender_api::ImageKey;
#[derive(Clone, Deserialize, MallocSizeOf, Serialize)] #[derive(Clone, Deserialize, MallocSizeOf, Serialize)]
pub struct Image { pub struct Image {
@ -16,7 +17,7 @@ pub struct Image {
#[ignore_malloc_size_of = "Defined in ipc-channel"] #[ignore_malloc_size_of = "Defined in ipc-channel"]
pub bytes: IpcSharedMemory, pub bytes: IpcSharedMemory,
#[ignore_malloc_size_of = "Defined in webrender_api"] #[ignore_malloc_size_of = "Defined in webrender_api"]
pub id: Option<webrender_api::ImageKey>, pub id: Option<ImageKey>,
pub cors_status: CorsStatus, pub cors_status: CorsStatus,
} }

22
components/script/dom/gpucanvascontext.rs
View file

@ -25,6 +25,10 @@ use ipc_channel::ipc;
use script_layout_interface::HTMLCanvasDataSource; use script_layout_interface::HTMLCanvasDataSource;
use std::cell::Cell; use std::cell::Cell;
use webgpu::{wgpu::id, wgt, WebGPU, WebGPURequest, PRESENTATION_BUFFER_COUNT}; use webgpu::{wgpu::id, wgt, WebGPU, WebGPURequest, PRESENTATION_BUFFER_COUNT};
use webrender_api::{
units, ExternalImageData, ExternalImageId, ExternalImageType, ImageData, ImageDescriptor,
ImageDescriptorFlags, ImageFormat, ImageKey,
};
#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, Ord, PartialEq, PartialOrd)]
pub struct WebGPUContextId(pub u64); pub struct WebGPUContextId(pub u64);
@ -78,7 +82,7 @@ impl GPUCanvasContext {
let image_key = if self.webrender_image.get().is_some() { let image_key = if self.webrender_image.get().is_some() {
self.webrender_image.get().unwrap() self.webrender_image.get().unwrap()
} else { } else {
webrender_api::ImageKey::DUMMY ImageKey::DUMMY
}; };
HTMLCanvasDataSource::WebGPU(image_key) HTMLCanvasDataSource::WebGPU(image_key)
} }
@ -145,13 +149,13 @@ impl GPUCanvasContextMethods for GPUCanvasContext {
); );
} }
let image_desc = webrender_api::ImageDescriptor { let image_desc = ImageDescriptor {
format: match descriptor.format { format: match descriptor.format {
GPUTextureFormat::Rgba8unorm => webrender_api::ImageFormat::RGBA8, GPUTextureFormat::Rgba8unorm => ImageFormat::RGBA8,
GPUTextureFormat::Bgra8unorm => webrender_api::ImageFormat::BGRA8, GPUTextureFormat::Bgra8unorm => ImageFormat::BGRA8,
_ => panic!("SwapChain format({:?}) not supported", descriptor.format), _ => panic!("SwapChain format({:?}) not supported", descriptor.format),
}, },
size: webrender_api::units::DeviceIntSize::new( size: units::DeviceIntSize::new(
self.size.get().width as i32, self.size.get().width as i32,
self.size.get().height as i32, self.size.get().height as i32,
), ),
@ -160,13 +164,13 @@ impl GPUCanvasContextMethods for GPUCanvasContext {
as i32, as i32,
), ),
offset: 0, offset: 0,
flags: webrender_api::ImageDescriptorFlags::from_bits(1).unwrap(), flags: ImageDescriptorFlags::from_bits(1).unwrap(),
}; };
let image_data = webrender_api::ImageData::External(webrender_api::ExternalImageData { let image_data = ImageData::External(ExternalImageData {
id: webrender_api::ExternalImageId(self.context_id.0), id: ExternalImageId(self.context_id.0),
channel_index: 0, channel_index: 0,
image_type: webrender_api::ExternalImageType::Buffer, image_type: ExternalImageType::Buffer,
}); });
let (sender, receiver) = ipc::channel().unwrap(); let (sender, receiver) = ipc::channel().unwrap();

3
components/script/dom/gpuswapchain.rs
View file

@ -12,6 +12,7 @@ use crate::dom::gpucanvascontext::GPUCanvasContext;
use crate::dom::gputexture::GPUTexture; use crate::dom::gputexture::GPUTexture;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use webgpu::{WebGPU, WebGPURequest, WebGPUTexture}; use webgpu::{WebGPU, WebGPURequest, WebGPUTexture};
use webrender_api::ImageKey;
#[dom_struct] #[dom_struct]
pub struct GPUSwapChain { pub struct GPUSwapChain {
@ -56,7 +57,7 @@ impl GPUSwapChain {
} }
impl GPUSwapChain { impl GPUSwapChain {
pub fn destroy(&self, external_id: u64, image_key: webrender_api::ImageKey) { pub fn destroy(&self, external_id: u64, image_key: ImageKey) {
if let Err(e) = self.channel.0.send(( if let Err(e) = self.channel.0.send((
None, None,
WebGPURequest::DestroySwapChain { WebGPURequest::DestroySwapChain {

3
components/script/dom/webglrenderingcontext.rs
View file

@ -83,6 +83,7 @@ use std::cell::Cell;
use std::cmp; use std::cmp;
use std::ptr::{self, NonNull}; use std::ptr::{self, NonNull};
use std::rc::Rc; use std::rc::Rc;
use webrender_api::ImageKey;
// From the GLES 2.0.25 spec, page 85: // From the GLES 2.0.25 spec, page 85:
// //
@ -165,7 +166,7 @@ pub struct WebGLRenderingContext {
#[ignore_malloc_size_of = "Channels are hard"] #[ignore_malloc_size_of = "Channels are hard"]
webgl_sender: WebGLMessageSender, webgl_sender: WebGLMessageSender,
#[ignore_malloc_size_of = "Defined in webrender"] #[ignore_malloc_size_of = "Defined in webrender"]
webrender_image: webrender_api::ImageKey, webrender_image: ImageKey,
webgl_version: WebGLVersion, webgl_version: WebGLVersion,
glsl_version: WebGLSLVersion, glsl_version: WebGLSLVersion,
#[ignore_malloc_size_of = "Defined in surfman"] #[ignore_malloc_size_of = "Defined in surfman"]

7
components/script_layout_interface/lib.rs
View file

@ -27,6 +27,7 @@ use servo_url::{ImmutableOrigin, ServoUrl};
use std::any::Any; use std::any::Any;
use std::sync::atomic::AtomicIsize; use std::sync::atomic::AtomicIsize;
use style::data::ElementData; use style::data::ElementData;
use webrender_api::ImageKey;
#[derive(MallocSizeOf)] #[derive(MallocSizeOf)]
pub struct StyleData { pub struct StyleData {
@ -121,9 +122,9 @@ pub enum LayoutElementType {
} }
pub enum HTMLCanvasDataSource { pub enum HTMLCanvasDataSource {
WebGL(webrender_api::ImageKey), WebGL(ImageKey),
Image(Option<IpcSender<CanvasMsg>>), Image(Option<IpcSender<CanvasMsg>>),
WebGPU(webrender_api::ImageKey), WebGPU(ImageKey),
} }
pub struct HTMLCanvasData { pub struct HTMLCanvasData {
@ -162,5 +163,5 @@ pub struct PendingImage {
} }
pub struct HTMLMediaData { pub struct HTMLMediaData {
pub current_frame: Option<(webrender_api::ImageKey, i32, i32)>, pub current_frame: Option<(ImageKey, i32, i32)>,
} }

27
components/script_traits/lib.rs
View file

@ -25,6 +25,11 @@ pub mod transferable;
pub mod webdriver_msg; pub mod webdriver_msg;
use crate::compositor::CompositorDisplayListInfo; use crate::compositor::CompositorDisplayListInfo;
pub use crate::script_msg::{
DOMMessage, EventResult, HistoryEntryReplacement, IFrameSizeMsg, Job, JobError, JobResult,
JobResultValue, JobType, LayoutMsg, LogEntry, SWManagerMsg, SWManagerSenders, ScopeThings,
ScriptMsg, ServiceWorkerMsg,
};
use crate::serializable::{BlobData, BlobImpl}; use crate::serializable::{BlobData, BlobImpl};
use crate::transferable::MessagePortImpl; use crate::transferable::MessagePortImpl;
use crate::webdriver_msg::{LoadStatus, WebDriverScriptCommand}; use crate::webdriver_msg::{LoadStatus, WebDriverScriptCommand};
@ -74,16 +79,10 @@ use webrender_api::units::{
DeviceIntSize, DevicePixel, LayoutPixel, LayoutPoint, LayoutSize, WorldPoint, DeviceIntSize, DevicePixel, LayoutPixel, LayoutPoint, LayoutSize, WorldPoint,
}; };
use webrender_api::{ use webrender_api::{
BuiltDisplayList, DocumentId, ExternalImageData, ExternalScrollId, ImageData, ImageDescriptor, BuiltDisplayList, BuiltDisplayListDescriptor, DocumentId, ExternalImageData, ExternalScrollId,
ImageKey, ScrollClamping, HitTestFlags, ImageData, ImageDescriptor, ImageKey, PipelineId as WebRenderPipelineId,
ScrollClamping,
}; };
use webrender_api::{BuiltDisplayListDescriptor, HitTestFlags};
pub use crate::script_msg::{
DOMMessage, HistoryEntryReplacement, Job, JobError, JobResult, JobResultValue, JobType,
SWManagerMsg, SWManagerSenders, ScopeThings, ServiceWorkerMsg,
};
pub use crate::script_msg::{EventResult, IFrameSizeMsg, LayoutMsg, LogEntry, ScriptMsg};
/// The address of a node. Layout sends these back. They must be validated via /// The address of a node. Layout sends these back. They must be validated via
/// `from_untrusted_node_address` before they can be used, because we do not trust layout. /// `from_untrusted_node_address` before they can be used, because we do not trust layout.
@ -1128,7 +1127,7 @@ pub struct CompositorHitTestResult {
#[derive(Deserialize, Serialize)] #[derive(Deserialize, Serialize)]
pub enum WebrenderMsg { pub enum WebrenderMsg {
/// Inform WebRender of the existence of this pipeline. /// Inform WebRender of the existence of this pipeline.
SendInitialTransaction(webrender_api::PipelineId), SendInitialTransaction(WebRenderPipelineId),
/// Perform a scroll operation. /// Perform a scroll operation.
SendScrollNode(LayoutPoint, ExternalScrollId, ScrollClamping), SendScrollNode(LayoutPoint, ExternalScrollId, ScrollClamping),
/// Inform WebRender of a new display list for the given pipeline. /// Inform WebRender of a new display list for the given pipeline.
@ -1145,7 +1144,7 @@ pub enum WebrenderMsg {
/// Perform a hit test operation. The result will be returned via /// Perform a hit test operation. The result will be returned via
/// the provided channel sender. /// the provided channel sender.
HitTest( HitTest(
Option<webrender_api::PipelineId>, Option<WebRenderPipelineId>,
WorldPoint, WorldPoint,
HitTestFlags, HitTestFlags,
IpcSender<Vec<CompositorHitTestResult>>, IpcSender<Vec<CompositorHitTestResult>>,
@ -1168,7 +1167,7 @@ impl WebrenderIpcSender {
} }
/// Inform WebRender of the existence of this pipeline. /// Inform WebRender of the existence of this pipeline.
pub fn send_initial_transaction(&self, pipeline: webrender_api::PipelineId) { pub fn send_initial_transaction(&self, pipeline: WebRenderPipelineId) {
if let Err(e) = self.0.send(WebrenderMsg::SendInitialTransaction(pipeline)) { if let Err(e) = self.0.send(WebrenderMsg::SendInitialTransaction(pipeline)) {
warn!("Error sending initial transaction: {}", e); warn!("Error sending initial transaction: {}", e);
} }
@ -1193,7 +1192,7 @@ impl WebrenderIpcSender {
pub fn send_display_list( pub fn send_display_list(
&self, &self,
display_list_info: CompositorDisplayListInfo, display_list_info: CompositorDisplayListInfo,
(_, content_size, list): (webrender_api::PipelineId, LayoutSize, BuiltDisplayList), (_, content_size, list): (WebRenderPipelineId, LayoutSize, BuiltDisplayList),
) { ) {
let (display_list_data, display_list_descriptor) = list.into_data(); let (display_list_data, display_list_descriptor) = list.into_data();
let (display_list_sender, display_list_receiver) = ipc::bytes_channel().unwrap(); let (display_list_sender, display_list_receiver) = ipc::bytes_channel().unwrap();
@ -1215,7 +1214,7 @@ impl WebrenderIpcSender {
/// and a result is available. /// and a result is available.
pub fn hit_test( pub fn hit_test(
&self, &self,
pipeline: Option<webrender_api::PipelineId>, pipeline: Option<WebRenderPipelineId>,
point: WorldPoint, point: WorldPoint,
flags: HitTestFlags, flags: HitTestFlags,
) -> Vec<CompositorHitTestResult> { ) -> Vec<CompositorHitTestResult> {

17
components/servo/lib.rs
View file

@ -51,6 +51,7 @@ pub use style;
pub use style_traits; pub use style_traits;
pub use webgpu; pub use webgpu;
pub use webrender_api; pub use webrender_api;
use webrender_api::{DocumentId, FontInstanceKey, FontKey, ImageKey, RenderApiSender};
pub use webrender_surfman; pub use webrender_surfman;
pub use webrender_traits; pub use webrender_traits;
@ -226,7 +227,7 @@ impl webrender_api::RenderNotifier for RenderNotifier {
fn new_frame_ready( fn new_frame_ready(
&self, &self,
_document_id: webrender_api::DocumentId, _document_id: DocumentId,
scrolled: bool, scrolled: bool,
composite_needed: bool, composite_needed: bool,
_render_time_ns: Option<u64>, _render_time_ns: Option<u64>,
@ -829,8 +830,8 @@ fn create_constellation(
time_profiler_chan: time::ProfilerChan, time_profiler_chan: time::ProfilerChan,
mem_profiler_chan: mem::ProfilerChan, mem_profiler_chan: mem::ProfilerChan,
devtools_sender: Option<Sender<devtools_traits::DevtoolsControlMsg>>, devtools_sender: Option<Sender<devtools_traits::DevtoolsControlMsg>>,
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: RenderApiSender,
webxr_registry: webxr_api::Registry, webxr_registry: webxr_api::Registry,
player_context: WindowGLContext, player_context: WindowGLContext,
webgl_threads: Option<WebGLThreads>, webgl_threads: Option<WebGLThreads>,
@ -920,18 +921,14 @@ fn create_constellation(
struct FontCacheWR(CompositorProxy); struct FontCacheWR(CompositorProxy);
impl gfx_traits::WebrenderApi for FontCacheWR { impl gfx_traits::WebrenderApi for FontCacheWR {
fn add_font_instance( fn add_font_instance(&self, font_key: FontKey, size: f32) -> FontInstanceKey {
&self,
font_key: webrender_api::FontKey,
size: f32,
) -> webrender_api::FontInstanceKey {
let (sender, receiver) = unbounded(); let (sender, receiver) = unbounded();
let _ = self.0.send(Msg::Webrender(WebrenderMsg::Font( let _ = self.0.send(Msg::Webrender(WebrenderMsg::Font(
WebrenderFontMsg::AddFontInstance(font_key, size, sender), WebrenderFontMsg::AddFontInstance(font_key, size, sender),
))); )));
receiver.recv().unwrap() receiver.recv().unwrap()
} }
fn add_font(&self, data: gfx_traits::FontData) -> webrender_api::FontKey { fn add_font(&self, data: gfx_traits::FontData) -> FontKey {
let (sender, receiver) = unbounded(); let (sender, receiver) = unbounded();
let _ = self.0.send(Msg::Webrender(WebrenderMsg::Font( let _ = self.0.send(Msg::Webrender(WebrenderMsg::Font(
WebrenderFontMsg::AddFont(data, sender), WebrenderFontMsg::AddFont(data, sender),
@ -944,7 +941,7 @@ impl gfx_traits::WebrenderApi for FontCacheWR {
struct CanvasWebrenderApi(CompositorProxy); struct CanvasWebrenderApi(CompositorProxy);
impl canvas_paint_thread::WebrenderApi for CanvasWebrenderApi { impl canvas_paint_thread::WebrenderApi for CanvasWebrenderApi {
fn generate_key(&self) -> Result<webrender_api::ImageKey, ()> { fn generate_key(&self) -> Result<ImageKey, ()> {
let (sender, receiver) = unbounded(); let (sender, receiver) = unbounded();
let _ = self.0.send(Msg::Webrender(WebrenderMsg::Canvas( let _ = self.0.send(Msg::Webrender(WebrenderMsg::Canvas(
WebrenderCanvasMsg::GenerateKey(sender), WebrenderCanvasMsg::GenerateKey(sender),

40
components/webgpu/lib.rs
View file

@ -27,6 +27,10 @@ use std::rc::Rc;
use std::slice; use std::slice;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use webrender_api::{
DirtyRect, DocumentId, ExternalImageId, ImageData, ImageDescriptor, ImageKey, RenderApi,
RenderApiSender, Transaction,
};
use webrender_traits::{ use webrender_traits::{
WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageHandlerType, WebrenderExternalImageApi, WebrenderExternalImageRegistry, WebrenderImageHandlerType,
WebrenderImageSource, WebrenderImageSource,
@ -140,7 +144,7 @@ pub enum WebGPURequest {
descriptor: ComputePipelineDescriptor<'static>, descriptor: ComputePipelineDescriptor<'static>,
implicit_ids: Option<(id::PipelineLayoutId, Vec<id::BindGroupLayoutId>)>, implicit_ids: Option<(id::PipelineLayoutId, Vec<id::BindGroupLayoutId>)>,
}, },
CreateContext(IpcSender<webrender_api::ExternalImageId>), CreateContext(IpcSender<ExternalImageId>),
CreatePipelineLayout { CreatePipelineLayout {
device_id: id::DeviceId, device_id: id::DeviceId,
pipeline_layout_id: id::PipelineLayoutId, pipeline_layout_id: id::PipelineLayoutId,
@ -166,9 +170,9 @@ pub enum WebGPURequest {
device_id: id::DeviceId, device_id: id::DeviceId,
buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>, buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>,
external_id: u64, external_id: u64,
sender: IpcSender<webrender_api::ImageKey>, sender: IpcSender<ImageKey>,
image_desc: webrender_api::ImageDescriptor, image_desc: ImageDescriptor,
image_data: webrender_api::ImageData, image_data: ImageData,
}, },
CreateTexture { CreateTexture {
device_id: id::DeviceId, device_id: id::DeviceId,
@ -184,7 +188,7 @@ pub enum WebGPURequest {
DestroyBuffer(id::BufferId), DestroyBuffer(id::BufferId),
DestroySwapChain { DestroySwapChain {
external_id: u64, external_id: u64,
image_key: webrender_api::ImageKey, image_key: ImageKey,
}, },
DestroyTexture(id::TextureId), DestroyTexture(id::TextureId),
Exit(IpcSender<()>), Exit(IpcSender<()>),
@ -267,8 +271,8 @@ pub struct WebGPU(pub IpcSender<(Option<ErrorScopeId>, WebGPURequest)>);
impl WebGPU { impl WebGPU {
pub fn new( pub fn new(
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: RenderApiSender,
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>, wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>,
) -> Option<(Self, IpcReceiver<WebGPUMsg>)> { ) -> Option<(Self, IpcReceiver<WebGPUMsg>)> {
@ -342,8 +346,8 @@ struct WGPU<'a> {
HashMap<id::BufferId, Rc<BufferMapInfo<'a, (Option<ErrorScopeId>, WebGPURequest)>>>, HashMap<id::BufferId, Rc<BufferMapInfo<'a, (Option<ErrorScopeId>, WebGPURequest)>>>,
//TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867) //TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867)
error_command_encoders: RefCell<HashMap<id::CommandEncoderId, String>>, error_command_encoders: RefCell<HashMap<id::CommandEncoderId, String>>,
webrender_api: webrender_api::RenderApi, webrender_api: RenderApi,
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>, wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>,
last_poll: Instant, last_poll: Instant,
@ -354,8 +358,8 @@ impl<'a> WGPU<'a> {
receiver: IpcReceiver<(Option<ErrorScopeId>, WebGPURequest)>, receiver: IpcReceiver<(Option<ErrorScopeId>, WebGPURequest)>,
sender: IpcSender<(Option<ErrorScopeId>, WebGPURequest)>, sender: IpcSender<(Option<ErrorScopeId>, WebGPURequest)>,
script_sender: IpcSender<WebGPUMsg>, script_sender: IpcSender<WebGPUMsg>,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: RenderApiSender,
webrender_document: webrender_api::DocumentId, webrender_document: DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>, external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>, wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>,
) -> Self { ) -> Self {
@ -769,7 +773,7 @@ impl<'a> WGPU<'a> {
}, },
); );
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.add_image(image_key, image_desc, image_data, None); txn.add_image(image_key, image_desc, image_data, None);
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -841,7 +845,7 @@ impl<'a> WGPU<'a> {
warn!("Unable to send FreeBuffer({:?}) ({:?})", *b_id, e); warn!("Unable to send FreeBuffer({:?}) ({:?})", *b_id, e);
}; };
} }
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.delete_image(image_key); txn.delete_image(image_key);
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -1191,12 +1195,12 @@ impl<'a> WGPU<'a> {
self.wgpu_image_map.lock().unwrap().get_mut(&external_id) self.wgpu_image_map.lock().unwrap().get_mut(&external_id)
{ {
present_data.data = data; present_data.data = data;
let mut txn = webrender_api::Transaction::new(); let mut txn = Transaction::new();
txn.update_image( txn.update_image(
present_data.image_key, present_data.image_key,
present_data.image_desc, present_data.image_desc,
present_data.image_data.clone(), present_data.image_data.clone(),
&webrender_api::DirtyRect::All, &DirtyRect::All,
); );
self.webrender_api self.webrender_api
.send_transaction(self.webrender_document, txn); .send_transaction(self.webrender_document, txn);
@ -1372,7 +1376,7 @@ pub struct PresentationData {
available_buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>, available_buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>,
queued_buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>, queued_buffer_ids: ArrayVec<id::BufferId, PRESENTATION_BUFFER_COUNT>,
buffer_stride: u32, buffer_stride: u32,
image_key: webrender_api::ImageKey, image_key: ImageKey,
image_desc: webrender_api::ImageDescriptor, image_desc: ImageDescriptor,
image_data: webrender_api::ImageData, image_data: ImageData,
} }

40
components/webrender_traits/lib.rs
View file

@ -5,11 +5,12 @@
#![deny(unsafe_code)] #![deny(unsafe_code)]
use euclid::default::Size2D; use euclid::default::Size2D;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use webrender_api::units::TexelRect; use webrender_api::units::TexelRect;
use webrender_api::{
ExternalImage, ExternalImageHandler, ExternalImageId, ExternalImageSource, ImageRendering,
};
/// This trait is used as a bridge between the different GL clients /// This trait is used as a bridge between the different GL clients
/// in Servo that handles WebRender ExternalImages and the WebRender /// in Servo that handles WebRender ExternalImages and the WebRender
@ -39,7 +40,7 @@ pub enum WebrenderImageHandlerType {
/// It ensures that external image identifiers are unique. /// It ensures that external image identifiers are unique.
pub struct WebrenderExternalImageRegistry { pub struct WebrenderExternalImageRegistry {
/// Map of all generated external images. /// Map of all generated external images.
external_images: HashMap<webrender_api::ExternalImageId, WebrenderImageHandlerType>, external_images: HashMap<ExternalImageId, WebrenderImageHandlerType>,
/// Id generator for the next external image identifier. /// Id generator for the next external image identifier.
next_image_id: u64, next_image_id: u64,
} }
@ -52,21 +53,18 @@ impl WebrenderExternalImageRegistry {
} }
} }
pub fn next_id( pub fn next_id(&mut self, handler_type: WebrenderImageHandlerType) -> ExternalImageId {
&mut self,
handler_type: WebrenderImageHandlerType,
) -> webrender_api::ExternalImageId {
self.next_image_id += 1; self.next_image_id += 1;
let key = webrender_api::ExternalImageId(self.next_image_id); let key = ExternalImageId(self.next_image_id);
self.external_images.insert(key, handler_type); self.external_images.insert(key, handler_type);
key key
} }
pub fn remove(&mut self, key: &webrender_api::ExternalImageId) { pub fn remove(&mut self, key: &ExternalImageId) {
self.external_images.remove(key); self.external_images.remove(key);
} }
pub fn get(&self, key: &webrender_api::ExternalImageId) -> Option<&WebrenderImageHandlerType> { pub fn get(&self, key: &ExternalImageId) -> Option<&WebrenderImageHandlerType> {
self.external_images.get(key) self.external_images.get(key)
} }
} }
@ -110,17 +108,17 @@ impl WebrenderExternalImageHandlers {
} }
} }
impl webrender_api::ExternalImageHandler for WebrenderExternalImageHandlers { impl ExternalImageHandler for WebrenderExternalImageHandlers {
/// Lock the external image. Then, WR could start to read the /// Lock the external image. Then, WR could start to read the
/// image content. /// image content.
/// The WR client should not change the image content until the /// The WR client should not change the image content until the
/// unlock() call. /// unlock() call.
fn lock( fn lock(
&mut self, &mut self,
key: webrender_api::ExternalImageId, key: ExternalImageId,
_channel_index: u8, _channel_index: u8,
_rendering: webrender_api::ImageRendering, _rendering: ImageRendering,
) -> webrender_api::ExternalImage { ) -> ExternalImage {
let external_images = self.external_images.lock().unwrap(); let external_images = self.external_images.lock().unwrap();
let handler_type = external_images let handler_type = external_images
.get(&key) .get(&key)
@ -132,9 +130,9 @@ impl webrender_api::ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageSource::TextureHandle(b) => b, WebrenderImageSource::TextureHandle(b) => b,
_ => panic!("Wrong type"), _ => panic!("Wrong type"),
}; };
webrender_api::ExternalImage { ExternalImage {
uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0), uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0),
source: webrender_api::ExternalImageSource::NativeTexture(texture_id), source: ExternalImageSource::NativeTexture(texture_id),
} }
}, },
WebrenderImageHandlerType::Media => { WebrenderImageHandlerType::Media => {
@ -143,9 +141,9 @@ impl webrender_api::ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageSource::TextureHandle(b) => b, WebrenderImageSource::TextureHandle(b) => b,
_ => panic!("Wrong type"), _ => panic!("Wrong type"),
}; };
webrender_api::ExternalImage { ExternalImage {
uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0), uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0),
source: webrender_api::ExternalImageSource::NativeTexture(texture_id), source: ExternalImageSource::NativeTexture(texture_id),
} }
}, },
WebrenderImageHandlerType::WebGPU => { WebrenderImageHandlerType::WebGPU => {
@ -154,9 +152,9 @@ impl webrender_api::ExternalImageHandler for WebrenderExternalImageHandlers {
WebrenderImageSource::Raw(b) => b, WebrenderImageSource::Raw(b) => b,
_ => panic!("Wrong type"), _ => panic!("Wrong type"),
}; };
webrender_api::ExternalImage { ExternalImage {
uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0), uv: TexelRect::new(0.0, size.height as f32, size.width as f32, 0.0),
source: webrender_api::ExternalImageSource::RawData(buffer), source: ExternalImageSource::RawData(buffer),
} }
}, },
} }
@ -164,7 +162,7 @@ impl webrender_api::ExternalImageHandler for WebrenderExternalImageHandlers {
/// Unlock the external image. The WR should not read the image /// Unlock the external image. The WR should not read the image
/// content after this call. /// content after this call.
fn unlock(&mut self, key: webrender_api::ExternalImageId, _channel_index: u8) { fn unlock(&mut self, key: ExternalImageId, _channel_index: u8) {
let external_images = self.external_images.lock().unwrap(); let external_images = self.external_images.lock().unwrap();
let handler_type = external_images let handler_type = external_images
.get(&key) .get(&key)