Auto merge of #26335 - jdm:wrup, r=SimonSapin

Update webrender.

Cargo.lock

@@ -418,6 +418,17 @@ dependencies = [
  "alloc-stdlib",
 ]
 
+[[package]]
+name = "build-parallel"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b5f8b148c1884e660514fb1205f36b595e96df4daac5ad526a23db44937de77"
+dependencies = [
+ "crossbeam-utils",
+ "jobserver",
+ "num_cpus",
+]
+
 [[package]]
 name = "byte-slice-cast"
 version = "0.2.0"
@@ -495,7 +506,7 @@ dependencies = [
  "embedder_traits",
  "euclid",
  "fnv",
- "gleam 0.9.2",
+ "gleam 0.11.0",
  "half",
  "ipc-channel",
  "log",
@@ -752,7 +763,7 @@ dependencies = [
  "embedder_traits",
  "euclid",
  "gfx_traits",
- "gleam 0.9.2",
+ "gleam 0.11.0",
  "image",
  "ipc-channel",
  "keyboard-types",
@@ -1312,8 +1323,6 @@ checksum = "0bd1369e02db5e9b842a9b67bce8a2fcc043beafb2ae8a799dd482d46ea1ff0d"
 dependencies = [
  "lazy_static",
  "libc",
- "serde",
- "serde_derive",
  "winapi",
 ]
 
@@ -1761,9 +1770,9 @@ dependencies = [
  "app_units",
  "bitflags",
  "byteorder",
- "core-foundation 0.6.4",
+ "core-foundation 0.7.0",
- "core-graphics 0.17.3",
+ "core-graphics 0.19.0",
- "core-text 13.2.0",
+ "core-text 15.0.0",
  "dwrote 0.11.0",
  "euclid",
  "fnv",
@@ -2016,6 +2025,15 @@ version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
 
+[[package]]
+name = "glslopt"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f22b383fcf6f85c4a268af39a0758ec40970e5f9f8fe9809e4415d48409b8379"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "gobject-sys"
 version = "0.9.1"
@@ -2734,13 +2752,11 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jobserver"
-version = "0.1.17"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b1d42ef453b30b7387e113da1c83ab1605d90c5b4e0eb8e96d016ed3b8c160"
+checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2"
 dependencies = [
- "getrandom",
  "libc",
- "log",
 ]
 
 [[package]]
@@ -3077,7 +3093,7 @@ dependencies = [
  "euclid",
  "gaol",
  "gfx",
- "gleam 0.9.2",
+ "gleam 0.11.0",
  "gstreamer",
  "ipc-channel",
  "keyboard-types",
@@ -3918,7 +3934,7 @@ dependencies = [
 [[package]]
 name = "peek-poke"
 version = "0.2.0"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
  "euclid",
  "peek-poke-derive 0.2.1",
@@ -3945,7 +3961,7 @@ dependencies = [
 [[package]]
 name = "peek-poke-derive"
 version = "0.2.1"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
  "proc-macro2 1.0.1",
  "quote 1.0.2",
@@ -5319,6 +5335,9 @@ name = "smallvec"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05720e22615919e4734f6a99ceae50d00226c3c5aca406e102ebc33298214e0a"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "smithay-client-toolkit"
@@ -5725,12 +5744,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "thread_profiler"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5920e77802b177479ab5795767fa48e68f61b2f516c2ac0041e2978dd8efe483"
-
 [[package]]
 name = "tiff"
 version = "0.4.0"
@@ -6001,6 +6014,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "tracy-rs"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3aa118469b61af5fead107a4882dc4661a05591b6653bbc546c1c8bbc181047"
+
 [[package]]
 name = "truetype"
 version = "0.26.0"
@@ -6361,22 +6380,24 @@ dependencies = [
 [[package]]
 name = "webrender"
 version = "0.61.0"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
  "base64 0.10.1",
  "bincode",
  "bitflags",
+ "build-parallel",
  "byteorder",
  "cfg-if",
- "core-foundation 0.6.4",
+ "core-foundation 0.7.0",
- "core-graphics 0.17.3",
+ "core-graphics 0.19.0",
- "core-text 13.2.0",
+ "core-text 15.0.0",
  "cstr",
- "dwrote 0.9.0",
+ "dwrote 0.11.0",
  "euclid",
  "freetype",
  "fxhash",
- "gleam 0.9.2",
+ "gleam 0.11.0",
+ "glslopt",
  "image",
  "lazy_static",
  "libc",
@@ -6388,11 +6409,10 @@ dependencies = [
  "ron",
  "serde",
  "serde_json",
- "sha2",
+ "smallvec 1.3.0",
- "smallvec 0.6.13",
  "svg_fmt",
- "thread_profiler",
  "time",
+ "tracy-rs",
  "webrender_api",
  "webrender_build",
  "wr_malloc_size_of",
@@ -6402,13 +6422,13 @@ dependencies = [
 [[package]]
 name = "webrender_api"
 version = "0.61.0"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
  "app_units",
  "bitflags",
  "byteorder",
- "core-foundation 0.6.4",
+ "core-foundation 0.7.0",
- "core-graphics 0.17.3",
+ "core-graphics 0.19.0",
  "derive_more",
  "euclid",
  "malloc_size_of_derive",
@@ -6423,9 +6443,10 @@ dependencies = [
 [[package]]
 name = "webrender_build"
 version = "0.0.1"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
- "sha2",
+ "bitflags",
+ "lazy_static",
 ]
 
 [[package]]
@@ -6600,7 +6621,7 @@ dependencies = [
 [[package]]
 name = "wr_malloc_size_of"
 version = "0.0.1"
-source = "git+https://github.com/servo/webrender#4ba17a61580a03b68881ffba7ee22bcf8e1aac72"
+source = "git+https://github.com/servo/webrender#01082a9091ab98c392af8934d04271eb1dd546df"
 dependencies = [
  "app_units",
  "euclid",

components/canvas/Cargo.toml

@@ -25,7 +25,7 @@ cssparser = "0.27"
 embedder_traits = {path = "../embedder_traits"}
 euclid = "0.20"
 fnv = "1.0"
-gleam = "0.9"
+gleam = "0.11"
 half = "1"
 ipc-channel = "0.14"
 log = "0.4"

components/canvas/canvas_data.rs

@@ -368,6 +368,7 @@ pub struct CanvasData<'a> {
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
     webrender_api: webrender_api::RenderApi,
+    webrender_doc: webrender_api::DocumentId,
     image_key: Option<webrender_api::ImageKey>,
     /// An old webrender image key that can be deleted when the next epoch ends.
     old_image_key: Option<webrender_api::ImageKey>,
@@ -384,6 +385,7 @@ impl<'a> CanvasData<'a> {
     pub fn new(
         size: Size2D<u64>,
         webrender_api_sender: webrender_api::RenderApiSender,
+        webrender_doc: webrender_api::DocumentId,
         antialias: AntialiasMode,
         canvas_id: CanvasId,
     ) -> CanvasData<'a> {
@@ -397,6 +399,7 @@ impl<'a> CanvasData<'a> {
             state: CanvasPaintState::new(antialias),
             saved_states: vec![],
             webrender_api: webrender_api,
+            webrender_doc,
             image_key: None,
             old_image_key: None,
             very_old_image_key: None,
@@ -996,7 +999,7 @@ impl<'a> CanvasData<'a> {
             txn.delete_image(image_key);
         }
 
-        self.webrender_api.update_resources(txn.resource_updates);
+        self.webrender_api.send_transaction(self.webrender_doc, txn);
 
         let data = CanvasImageData {
             image_key: self.image_key.unwrap(),
@@ -1116,7 +1119,7 @@ impl<'a> Drop for CanvasData<'a> {
             txn.delete_image(image_key);
         }
 
-        self.webrender_api.update_resources(txn.resource_updates);
+        self.webrender_api.send_transaction(self.webrender_doc, txn);
     }
 }
 

components/canvas/canvas_paint_thread.rs

@@ -75,11 +75,13 @@ impl<'a> CanvasPaintThread<'a> {
                                     id_sender: creator,
                                     size,
                                     webrender_sender: webrenderer_api_sender,
+                                    webrender_doc,
                                     antialias
                                 }) => {
                                     let canvas_id = canvas_paint_thread.create_canvas(
                                         size,
                                         webrenderer_api_sender,
+                                        webrender_doc,
                                         antialias,
                                     );
                                     creator.send(canvas_id).unwrap();
@@ -103,6 +105,7 @@ impl<'a> CanvasPaintThread<'a> {
         &mut self,
         size: Size2D<u64>,
         webrender_api_sender: webrender_api::RenderApiSender,
+        webrender_doc: webrender_api::DocumentId,
         antialias: bool,
     ) -> CanvasId {
         let antialias = if antialias {
@@ -114,7 +117,13 @@ impl<'a> CanvasPaintThread<'a> {
         let canvas_id = self.next_canvas_id.clone();
         self.next_canvas_id.0 += 1;
 
-        let canvas_data = CanvasData::new(size, webrender_api_sender, antialias, canvas_id.clone());
+        let canvas_data = CanvasData::new(
+            size,
+            webrender_api_sender,
+            webrender_doc,
+            antialias,
+            canvas_id.clone(),
+        );
         self.canvases.insert(canvas_id.clone(), canvas_data);
 
         canvas_id

components/canvas/webgl_mode/inprocess.rs

@@ -40,6 +40,7 @@ impl WebGLComm {
         surfman: WebrenderSurfman,
         webrender_gl: Rc<dyn gleam::gl::Gl>,
         webrender_api_sender: webrender_api::RenderApiSender,
+        webrender_doc: webrender_api::DocumentId,
         external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
         api_type: GlType,
     ) -> WebGLComm {
@@ -53,6 +54,7 @@ impl WebGLComm {
         // This implementation creates a single `WebGLThread` for all the pipelines.
         let init = WebGLThreadInit {
             webrender_api_sender,
+            webrender_doc,
             external_images,
             sender: sender.clone(),
             receiver,

components/canvas/webgl_thread.rs

@@ -221,6 +221,7 @@ pub(crate) struct WebGLThread {
     device: Device,
     /// Channel used to generate/update or delete `webrender_api::ImageKey`s.
     webrender_api: webrender_api::RenderApi,
+    webrender_doc: webrender_api::DocumentId,
     /// Map of live WebGLContexts.
     contexts: FnvHashMap<WebGLContextId, GLContextData>,
     /// Cached information for WebGLContexts.
@@ -257,6 +258,7 @@ pub type SurfaceProvider = Box<dyn surfman_chains::SurfaceProvider<Device> + Sen
 pub(crate) struct WebGLThreadInit {
     pub webxr_surface_providers: SurfaceProviders,
     pub webrender_api_sender: webrender_api::RenderApiSender,
+    pub webrender_doc: webrender_api::DocumentId,
     pub external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
     pub sender: WebGLSender<WebGLMsg>,
     pub receiver: WebGLReceiver<WebGLMsg>,
@@ -276,6 +278,7 @@ impl WebGLThread {
     pub(crate) fn new(
         WebGLThreadInit {
             webrender_api_sender,
+            webrender_doc,
             external_images,
             sender,
             receiver,
@@ -293,6 +296,7 @@ impl WebGLThread {
                 .create_device(&adapter)
                 .expect("Couldn't open WebGL device!"),
             webrender_api: webrender_api_sender.create_api(),
+            webrender_doc,
             contexts: Default::default(),
             cached_context_info: Default::default(),
             bound_context_id: None,
@@ -652,6 +656,7 @@ impl WebGLThread {
 
         let image_key = Self::create_wr_external_image(
             &self.webrender_api,
+            self.webrender_doc,
             size.to_i32(),
             has_alpha,
             id,
@@ -714,6 +719,7 @@ impl WebGLThread {
         let texture_target = current_wr_texture_target(&self.device);
         Self::update_wr_external_image(
             &self.webrender_api,
+            self.webrender_doc,
             size.to_i32(),
             has_alpha,
             context_id,
@@ -732,7 +738,7 @@ impl WebGLThread {
         if let Some(info) = self.cached_context_info.remove(&context_id) {
             let mut txn = webrender_api::Transaction::new();
             txn.delete_image(info.image_key);
-            self.webrender_api.update_resources(txn.resource_updates)
+            self.webrender_api.send_transaction(self.webrender_doc, txn)
         }
 
         // We need to make the context current so its resources can be disposed of.
@@ -1016,6 +1022,7 @@ impl WebGLThread {
     /// Creates a `webrender_api::ImageKey` that uses shared textures.
     fn create_wr_external_image(
         webrender_api: &webrender_api::RenderApi,
+        webrender_doc: webrender_api::DocumentId,
         size: Size2D<i32>,
         alpha: bool,
         context_id: WebGLContextId,
@@ -1027,7 +1034,7 @@ impl WebGLThread {
         let image_key = webrender_api.generate_image_key();
         let mut txn = webrender_api::Transaction::new();
         txn.add_image(image_key, descriptor, data, None);
-        webrender_api.update_resources(txn.resource_updates);
+        webrender_api.send_transaction(webrender_doc, txn);
 
         image_key
     }
@@ -1035,6 +1042,7 @@ impl WebGLThread {
     /// Updates a `webrender_api::ImageKey` that uses shared textures.
     fn update_wr_external_image(
         webrender_api: &webrender_api::RenderApi,
+        webrender_doc: webrender_api::DocumentId,
         size: Size2D<i32>,
         alpha: bool,
         context_id: WebGLContextId,
@@ -1046,7 +1054,7 @@ impl WebGLThread {
 
         let mut txn = webrender_api::Transaction::new();
         txn.update_image(image_key, descriptor, data, &webrender_api::DirtyRect::All);
-        webrender_api.update_resources(txn.resource_updates);
+        webrender_api.send_transaction(webrender_doc, txn);
     }
 
     /// Helper function to create a `webrender_api::ImageDescriptor`.

components/canvas_traits/lib.rs

@@ -27,6 +27,7 @@ pub enum ConstellationCanvasMsg {
         id_sender: Sender<CanvasId>,
         size: Size2D<u64>,
         webrender_sender: webrender_api::RenderApiSender,
+        webrender_doc: webrender_api::DocumentId,
         antialias: bool,
     },
     Exit,

components/compositing/Cargo.toml

@@ -21,7 +21,7 @@ crossbeam-channel = "0.4"
 embedder_traits = {path = "../embedder_traits"}
 euclid = "0.20"
 gfx_traits = {path = "../gfx_traits"}
-gleam = {version = "0.9", optional = true}
+gleam = {version = "0.11", optional = true}
 image = "0.23"
 ipc-channel = "0.14"
 libc = "0.2"

components/constellation/constellation.rs

@@ -738,6 +738,7 @@ enum WebrenderMsg {
 fn handle_webrender_message(
     pending_wr_frame: &AtomicBool,
     webrender_api: &webrender_api::RenderApi,
+    webrender_doc: webrender_api::DocumentId,
     msg: WebrenderMsg,
 ) {
     match msg {
@@ -810,9 +811,26 @@ fn handle_webrender_message(
             let _ = sender.send(webrender_api.generate_image_key());
         },
 
-        WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateResources(updates)) |
+        WebrenderMsg::Layout(script_traits::WebrenderMsg::UpdateImages(updates)) => {
-        WebrenderMsg::Net(net_traits::WebrenderImageMsg::UpdateResources(updates)) => {
+            let mut txn = webrender_api::Transaction::new();
-            webrender_api.update_resources(updates);
+            for update in updates {
+                match update {
+                    script_traits::ImageUpdate::AddImage(key, desc, data) => {
+                        txn.add_image(key, desc, data, None)
+                    },
+                    script_traits::ImageUpdate::DeleteImage(key) => txn.delete_image(key),
+                    script_traits::ImageUpdate::UpdateImage(key, desc, data) => {
+                        txn.update_image(key, desc, data, &webrender_api::DirtyRect::All)
+                    },
+                }
+            }
+            webrender_api.send_transaction(webrender_doc, txn);
+        },
+
+        WebrenderMsg::Net(net_traits::WebrenderImageMsg::AddImage(key, desc, data)) => {
+            let mut txn = webrender_api::Transaction::new();
+            txn.add_image(key, desc, data, None);
+            webrender_api.send_transaction(webrender_doc, txn);
         },
     }
 }
@@ -916,6 +934,7 @@ where
                     ipc::channel().expect("ipc channel failure");
 
                 let webrender_api = state.webrender_api_sender.create_api();
+                let webrender_doc = state.webrender_document;
                 let pending_wr_frame_clone = state.pending_wr_frame.clone();
                 ROUTER.add_route(
                     webrender_ipc_receiver.to_opaque(),
@@ -923,6 +942,7 @@ where
                         handle_webrender_message(
                             &pending_wr_frame_clone,
                             &webrender_api,
+                            webrender_doc,
                             WebrenderMsg::Layout(message.to().expect("conversion failure")),
                         )
                     }),
@@ -936,6 +956,7 @@ where
                         handle_webrender_message(
                             &pending_wr_frame_clone,
                             &webrender_api,
+                            webrender_doc,
                             WebrenderMsg::Net(message.to().expect("conversion failure")),
                         )
                     }),
@@ -4351,6 +4372,7 @@ where
             id_sender: canvas_id_sender,
             size,
             webrender_sender: webrender_api,
+            webrender_doc: self.webrender_document,
             antialias: self.enable_canvas_antialiasing,
         }) {
             return warn!("Create canvas paint thread failed ({})", e);

components/gfx/Cargo.toml

@@ -43,9 +43,9 @@ ucd = "0.1.1"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 byteorder = "1.0"
-core-foundation = "0.6"
+core-foundation = "0.7"
-core-graphics = "0.17"
+core-graphics = "0.19"
-core-text = "13.0"
+core-text = "15.0"
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
 freetype = "0.4"

components/gfx/font_cache_thread.rs

@@ -137,6 +137,7 @@ struct FontCache {
     core_resource_thread: CoreResourceThread,
     webrender_api: webrender_api::RenderApi,
     webrender_fonts: HashMap<Atom, webrender_api::FontKey>,
+    webrender_doc: webrender_api::DocumentId,
     font_instances: HashMap<(webrender_api::FontKey, Au), webrender_api::FontInstanceKey>,
 }
 
@@ -180,6 +181,7 @@ impl FontCache {
                 },
                 Command::GetFontInstance(font_key, size, result) => {
                     let webrender_api = &self.webrender_api;
+                    let doc = self.webrender_doc;
 
                     let instance_key =
                         *self
@@ -189,7 +191,7 @@ impl FontCache {
                                 let key = webrender_api.generate_font_instance_key();
                                 let mut txn = webrender_api::Transaction::new();
                                 txn.add_font_instance(key, font_key, size, None, None, Vec::new());
-                                webrender_api.update_resources(txn.resource_updates);
+                                webrender_api.send_transaction(doc, txn);
                                 key
                             });
 
@@ -389,6 +391,7 @@ impl FontCache {
 
     fn get_font_template_info(&mut self, template: Arc<FontTemplateData>) -> FontTemplateInfo {
         let webrender_api = &self.webrender_api;
+        let doc = self.webrender_doc;
         let webrender_fonts = &mut self.webrender_fonts;
 
         let font_key = *webrender_fonts
@@ -401,7 +404,7 @@ impl FontCache {
                     (None, Some(native_font)) => txn.add_native_font(font_key, native_font),
                     (None, None) => txn.add_raw_font(font_key, template.bytes(), 0),
                 }
-                webrender_api.update_resources(txn.resource_updates);
+                webrender_api.send_transaction(doc, txn);
                 font_key
             });
 
@@ -442,6 +445,7 @@ impl FontCacheThread {
     pub fn new(
         core_resource_thread: CoreResourceThread,
         webrender_api: webrender_api::RenderApi,
+        webrender_doc: webrender_api::DocumentId,
     ) -> FontCacheThread {
         let (chan, port) = ipc::channel().unwrap();
 
@@ -461,6 +465,7 @@ impl FontCacheThread {
                     font_context: FontContextHandle::new(),
                     core_resource_thread,
                     webrender_api,
+                    webrender_doc,
                     webrender_fonts: HashMap::new(),
                     font_instances: HashMap::new(),
                 };

components/layout/display_list/builder.rs

@@ -14,7 +14,9 @@ use crate::display_list::background::{self, get_cyclic};
 use crate::display_list::border;
 use crate::display_list::gradient;
 use crate::display_list::items::{self, BaseDisplayItem, ClipScrollNode};
-use crate::display_list::items::{ClipScrollNodeIndex, ClipScrollNodeType, ClippingAndScrolling};
+use crate::display_list::items::{
+    ClipScrollNodeIndex, ClipScrollNodeType, ClipType, ClippingAndScrolling,
+};
 use crate::display_list::items::{ClippingRegion, DisplayItem, DisplayItemMetadata, DisplayList};
 use crate::display_list::items::{CommonDisplayItem, DisplayListSection};
 use crate::display_list::items::{IframeDisplayItem, OpaqueNode};
@@ -70,7 +72,7 @@ use style_traits::ToCss;
 use webrender_api::units::{LayoutRect, LayoutTransform, LayoutVector2D};
 use webrender_api::{self, BorderDetails, BorderRadius, BorderSide, BoxShadowClipMode, ColorF};
 use webrender_api::{ColorU, ExternalScrollId, FilterOp, GlyphInstance, ImageRendering, LineStyle};
-use webrender_api::{NinePatchBorder, NinePatchBorderSource, NormalBorder};
+use webrender_api::{NinePatchBorder, NinePatchBorderSource, NormalBorder, PropertyBinding};
 use webrender_api::{ScrollSensitivity, StickyOffsetBounds};
 
 static THREAD_TINT_COLORS: [ColorF; 8] = [
@@ -424,15 +426,8 @@ impl<'a> DisplayListBuildState<'a> {
     }
 
     fn add_late_clip_node(&mut self, rect: LayoutRect, radii: BorderRadius) -> ClipScrollNodeIndex {
-        let mut clip = ClippingRegion::from_rect(rect);
+        let node =
-        clip.intersect_with_rounded_rect(rect, radii);
+            ClipScrollNode::rounded(rect, radii, self.current_clipping_and_scrolling.scrolling);
-
-        let node = ClipScrollNode {
-            parent_index: self.current_clipping_and_scrolling.scrolling,
-            clip,
-            content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
-            node_type: ClipScrollNodeType::Clip,
-        };
 
         // We want the scroll root to be defined before any possible item that could use it,
         // so we make sure that it is added to the beginning of the parent "real" (non-pseudo)
@@ -721,8 +716,9 @@ impl Fragment {
             state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new(
                 base,
                 webrender_api::RectangleDisplayItem {
-                    color: background_color.to_layout(),
+                    color: PropertyBinding::Value(background_color.to_layout()),
                     common: items::empty_common_item_properties(),
+                    bounds: bounds.to_layout(),
                 },
             )));
         });
@@ -1468,7 +1464,8 @@ impl Fragment {
                 base,
                 webrender_api::RectangleDisplayItem {
                     common: items::empty_common_item_properties(),
-                    color: background_color.to_layout(),
+                    color: PropertyBinding::Value(background_color.to_layout()),
+                    bounds: stacking_relative_border_box.to_layout(),
                 },
             )));
         }
@@ -1514,7 +1511,8 @@ impl Fragment {
             base,
             webrender_api::RectangleDisplayItem {
                 common: items::empty_common_item_properties(),
-                color: self.style().get_inherited_text().color.to_layout(),
+                color: PropertyBinding::Value(self.style().get_inherited_text().color.to_layout()),
+                bounds: insertion_point_bounds.to_layout(),
             },
         )));
     }
@@ -1697,7 +1695,8 @@ impl Fragment {
                 base,
                 webrender_api::RectangleDisplayItem {
                     common: items::empty_common_item_properties(),
-                    color: ColorF::TRANSPARENT,
+                    color: PropertyBinding::Value(ColorF::TRANSPARENT),
+                    bounds: content_size.to_layout(),
                 },
             )));
         }
@@ -2639,10 +2638,18 @@ impl BlockFlow {
             .to_physical(self.fragment.style.writing_mode);
         let clip_rect = border_box.inner_rect(border_widths);
 
-        let mut clip = ClippingRegion::from_rect(clip_rect.to_layout());
+        let clip = ClippingRegion::from_rect(clip_rect.to_layout());
         let radii = build_border_radius_for_inner_rect(border_box, &self.fragment.style);
         if !radii.is_zero() {
-            clip.intersect_with_rounded_rect(clip_rect.to_layout(), radii)
+            let node = ClipScrollNode::rounded(
+                clip_rect.to_layout(),
+                radii,
+                state.current_clipping_and_scrolling.scrolling,
+            );
+            let clip_id = state.add_clip_scroll_node(node);
+            let new_clipping_and_scrolling = ClippingAndScrolling::simple(clip_id);
+            self.base.clipping_and_scrolling = Some(new_clipping_and_scrolling);
+            state.current_clipping_and_scrolling = new_clipping_and_scrolling;
         }
 
         let content_size = self.base.overflow.scroll.origin + self.base.overflow.scroll.size;
@@ -2709,7 +2716,7 @@ impl BlockFlow {
             parent_index: self.clipping_and_scrolling().scrolling,
             clip: ClippingRegion::from_rect(clip_rect.to_layout()),
             content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
-            node_type: ClipScrollNodeType::Clip,
+            node_type: ClipScrollNodeType::Clip(ClipType::Rect),
         });
 
         let new_indices = ClippingAndScrolling::new(new_index, new_index);

components/layout/display_list/items.rs

@@ -24,7 +24,7 @@ use std::f32;
 use std::fmt;
 use style::computed_values::_servo_top_layer::T as InTopLayer;
 use webrender_api as wr;
-use webrender_api::units::{LayoutPixel, LayoutPoint, LayoutRect, LayoutSize, LayoutTransform};
+use webrender_api::units::{LayoutPixel, LayoutRect, LayoutTransform};
 use webrender_api::{
     BorderRadius, ClipId, ClipMode, CommonItemProperties, ComplexClipRegion, ExternalScrollId,
     FilterOp, GlyphInstance, GradientStop, ImageKey, MixBlendMode, PrimitiveFlags,
@@ -334,12 +334,18 @@ pub struct StickyFrameData {
     pub horizontal_offset_bounds: StickyOffsetBounds,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
+pub enum ClipType {
+    Rounded(ComplexClipRegion),
+    Rect,
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub enum ClipScrollNodeType {
     Placeholder,
     ScrollFrame(ScrollSensitivity, ExternalScrollId),
     StickyFrame(StickyFrameData),
-    Clip,
+    Clip(ClipType),
 }
 
 /// Defines a clip scroll node.
@@ -371,6 +377,24 @@ impl ClipScrollNode {
     pub fn is_placeholder(&self) -> bool {
         self.node_type == ClipScrollNodeType::Placeholder
     }
+
+    pub fn rounded(
+        clip_rect: LayoutRect,
+        radii: BorderRadius,
+        parent_index: ClipScrollNodeIndex,
+    ) -> ClipScrollNode {
+        let complex_region = ComplexClipRegion {
+            rect: clip_rect,
+            radii,
+            mode: ClipMode::Clip,
+        };
+        ClipScrollNode {
+            parent_index,
+            clip: ClippingRegion::from_rect(clip_rect),
+            content_rect: LayoutRect::zero(), // content_rect isn't important for clips.
+            node_type: ClipScrollNodeType::Clip(ClipType::Rounded(complex_region)),
+        }
+    }
 }
 
 /// One drawing command in the list.
@@ -455,7 +479,6 @@ pub fn empty_common_item_properties() -> CommonItemProperties {
         spatial_id: SpatialId::root_scroll_node(wr::PipelineId::dummy()),
         hit_info: None,
         flags: PrimitiveFlags::empty(),
-        item_key: None,
     }
 }
 
@@ -466,11 +489,6 @@ pub fn empty_common_item_properties() -> CommonItemProperties {
 pub struct ClippingRegion {
     /// The main rectangular region. This does not include any corners.
     pub main: LayoutRect,
-    /// Any complex regions.
-    ///
-    /// TODO(pcwalton): Atomically reference count these? Not sure if it's worth the trouble.
-    /// Measure and follow up.
-    pub complex: Vec<ComplexClipRegion>,
 }
 
 impl ClippingRegion {
@@ -479,7 +497,6 @@ impl ClippingRegion {
     pub fn empty() -> ClippingRegion {
         ClippingRegion {
             main: LayoutRect::zero(),
-            complex: Vec::new(),
         }
     }
 
@@ -488,45 +505,13 @@ impl ClippingRegion {
     pub fn max() -> ClippingRegion {
         ClippingRegion {
             main: LayoutRect::max_rect(),
-            complex: Vec::new(),
         }
     }
 
     /// Returns a clipping region that represents the given rectangle.
     #[inline]
     pub fn from_rect(rect: LayoutRect) -> ClippingRegion {
-        ClippingRegion {
+        ClippingRegion { main: rect }
-            main: rect,
-            complex: Vec::new(),
-        }
-    }
-
-    /// Intersects this clipping region with the given rounded rectangle.
-    #[inline]
-    pub fn intersect_with_rounded_rect(&mut self, rect: LayoutRect, radii: BorderRadius) {
-        let new_complex_region = ComplexClipRegion {
-            rect,
-            radii,
-            mode: ClipMode::Clip,
-        };
-
-        // FIXME(pcwalton): This is O(n²) worst case for disjoint clipping regions. Is that OK?
-        // They're slow anyway…
-        //
-        // Possibly relevant if we want to do better:
-        //
-        //     http://www.inrg.csie.ntu.edu.tw/algorithm2014/presentation/D&C%20Lee-84.pdf
-        for existing_complex_region in &mut self.complex {
-            if completely_encloses(&existing_complex_region, &new_complex_region) {
-                *existing_complex_region = new_complex_region;
-                return;
-            }
-            if completely_encloses(&new_complex_region, &existing_complex_region) {
-                return;
-            }
-        }
-
-        self.complex.push(new_complex_region);
     }
 }
 
@@ -536,46 +521,12 @@ impl fmt::Debug for ClippingRegion {
             write!(f, "ClippingRegion::Max")
         } else if *self == ClippingRegion::empty() {
             write!(f, "ClippingRegion::Empty")
-        } else if self.main == LayoutRect::max_rect() {
-            write!(f, "ClippingRegion(Complex={:?})", self.complex)
         } else {
-            write!(
+            write!(f, "ClippingRegion(Rect={:?})", self.main,)
-                f,
-                "ClippingRegion(Rect={:?}, Complex={:?})",
-                self.main, self.complex
-            )
         }
     }
 }
 
-// TODO(pcwalton): This could be more aggressive by considering points that touch the inside of
-// the border radius ellipse.
-fn completely_encloses(this: &ComplexClipRegion, other: &ComplexClipRegion) -> bool {
-    let left = this.radii.top_left.width.max(this.radii.bottom_left.width);
-    let top = this.radii.top_left.height.max(this.radii.top_right.height);
-    let right = this
-        .radii
-        .top_right
-        .width
-        .max(this.radii.bottom_right.width);
-    let bottom = this
-        .radii
-        .bottom_left
-        .height
-        .max(this.radii.bottom_right.height);
-    let interior = LayoutRect::new(
-        LayoutPoint::new(this.rect.origin.x + left, this.rect.origin.y + top),
-        LayoutSize::new(
-            this.rect.size.width - left - right,
-            this.rect.size.height - top - bottom,
-        ),
-    );
-    interior.origin.x <= other.rect.origin.x &&
-        interior.origin.y <= other.rect.origin.y &&
-        interior.max_x() >= other.rect.max_x() &&
-        interior.max_y() >= other.rect.max_y()
-}
-
 /// Metadata attached to each display item. This is useful for performing auxiliary threads with
 /// the display list involving hit testing: finding the originating DOM node and determining the
 /// cursor to use when the element is hovered over.

components/layout/display_list/mod.rs

@@ -12,7 +12,7 @@ pub use self::conversions::ToLayout;
 mod background;
 mod border;
 mod builder;
-mod conversions;
+pub(crate) mod conversions;
 mod gradient;
 pub mod items;
 mod webrender_helpers;

components/layout/display_list/webrender_helpers.rs

@@ -7,7 +7,7 @@
 //           This might be achieved by sharing types between WR and Servo display lists, or
 //           completely converting layout to directly generate WebRender display lists, for example.
 
-use crate::display_list::items::{BaseDisplayItem, ClipScrollNode, ClipScrollNodeType};
+use crate::display_list::items::{BaseDisplayItem, ClipScrollNode, ClipScrollNodeType, ClipType};
 use crate::display_list::items::{DisplayItem, DisplayList, StackingContextType};
 use msg::constellation_msg::PipelineId;
 use webrender_api::units::LayoutPoint;
@@ -269,16 +269,19 @@ impl DisplayItem {
                     .expect("Tried to use WebRender parent ClipId before it was defined.");
 
                 match node.node_type {
-                    ClipScrollNodeType::Clip => {
+                    ClipScrollNodeType::Clip(clip_type) => {
-                        let id = builder.define_clip(
+                        let space_and_clip_info = SpaceAndClipInfo {
-                            &SpaceAndClipInfo {
+                            clip_id: parent_clip_id,
-                                clip_id: parent_clip_id,
+                            spatial_id: parent_spatial_id,
-                                spatial_id: parent_spatial_id,
+                        };
+                        let id = match clip_type {
+                            ClipType::Rect => {
+                                builder.define_clip_rect(&space_and_clip_info, item_rect)
                             },
-                            item_rect,
+                            ClipType::Rounded(complex) => {
-                            node.clip.complex.clone(),
+                                builder.define_clip_rounded_rect(&space_and_clip_info, complex)
-                            None,
+                            },
-                        );
+                        };
 
                         state.spatial_ids[item.node_index.to_index()] = Some(parent_spatial_id);
                         state.clip_ids[item.node_index.to_index()] = Some(id);
@@ -292,8 +295,6 @@ impl DisplayItem {
                             Some(external_id),
                             node.content_rect,
                             node.clip.main,
-                            node.clip.complex.clone(),
-                            None,
                             scroll_sensitivity,
                             webrender_api::units::LayoutVector2D::zero(),
                         );
@@ -341,6 +342,5 @@ fn build_common_item_properties(
         // TODO(gw): Make use of the WR backface visibility functionality.
         flags: PrimitiveFlags::default(),
         hit_info: tag,
-        item_key: None,
     }
 }

components/layout/sequential.rs

@@ -5,6 +5,7 @@
 //! Implements sequential traversals over the DOM and flow trees.
 
 use crate::context::LayoutContext;
+use crate::display_list::conversions::ToLayout;
 use crate::display_list::items::{self, CommonDisplayItem, DisplayItem, DisplayListSection};
 use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
 use crate::floats::SpeculatedFloatPlacement;
@@ -19,6 +20,7 @@ use euclid::default::{Point2D, Rect, Size2D, Vector2D};
 use servo_config::opts;
 use style::servo::restyle_damage::ServoRestyleDamage;
 use webrender_api::units::LayoutPoint;
+use webrender_api::PropertyBinding;
 
 pub fn resolve_generated_content(root: &mut dyn Flow, layout_context: &LayoutContext) {
     ResolveGeneratedContent::new(&layout_context).traverse(root, 0);
@@ -83,8 +85,9 @@ pub fn build_display_list_for_subtree<'a>(
 
     // Create a base rectangle for the page background based on the root
     // background color.
+    let bounds = Rect::new(Point2D::new(Au::new(0), Au::new(0)), client_size);
     let base = state.create_base_display_item(
-        Rect::new(Point2D::new(Au::new(0), Au::new(0)), client_size),
+        bounds,
         flow_root.as_block().fragment.node,
         None,
         DisplayListSection::BackgroundAndBorders,
@@ -92,8 +95,9 @@ pub fn build_display_list_for_subtree<'a>(
     state.add_display_item(DisplayItem::Rectangle(CommonDisplayItem::new(
         base,
         webrender_api::RectangleDisplayItem {
-            color: background_color,
+            color: PropertyBinding::Value(background_color),
             common: items::empty_common_item_properties(),
+            bounds: bounds.to_layout(),
         },
     )));
 

components/layout_2020/display_list/mod.rs

@@ -341,8 +341,10 @@ impl<'a> BuilderForBoxFragment<'a> {
             // “The background color is clipped according to the background-clip
             //  value associated with the bottom-most background image layer.”
             let layer_index = b.background_image.0.len() - 1;
-            let (_, common) = background::painting_area(self, builder, layer_index);
+            let (bounds, common) = background::painting_area(self, builder, layer_index);
-            builder.wr.push_rect(&common, rgba(background_color))
+            builder
+                .wr
+                .push_rect(&common, *bounds, rgba(background_color))
         }
         // Reverse because the property is top layer first, we want to paint bottom layer first.
         for (index, image) in b.background_image.0.iter().enumerate().rev() {
@@ -587,15 +589,13 @@ fn clip_for_radii(
     if radii.is_zero() {
         None
     } else {
-        Some(builder.wr.define_clip(
+        Some(builder.wr.define_clip_rounded_rect(
             &builder.current_space_and_clip,
-            rect,
+            wr::ComplexClipRegion {
-            Some(wr::ComplexClipRegion {
                 rect,
                 radii,
                 mode: wr::ClipMode::Clip,
-            }),
+            },
-            None,
         ))
     }
 }

components/layout_2020/display_list/stacking_context.rs

@@ -605,8 +605,6 @@ impl BoxFragment {
                 self.scrollable_overflow(&containing_block_info.rect)
                     .to_webrender(),
                 padding_rect,
-                vec![], // complex_clips
-                None,   // image_mask
                 sensitivity,
                 LayoutVector2D::zero(),
             );

components/net/image_cache.rs

@@ -86,9 +86,7 @@ fn set_webrender_image_key(webrender_api: &WebrenderIpcSender, image: &mut Image
     };
     let data = webrender_api::ImageData::new(bytes);
     let image_key = webrender_api.generate_image_key();
-    let mut txn = webrender_api::Transaction::new();
+    webrender_api.add_image(image_key, descriptor, data);
-    txn.add_image(image_key, descriptor, data, None);
-    webrender_api.update_resources(txn.resource_updates);
     image.id = Some(image_key);
 }
 

components/net_traits/lib.rs

@@ -32,7 +32,7 @@ use mime::Mime;
 use msg::constellation_msg::HistoryStateId;
 use servo_url::{ImmutableOrigin, ServoUrl};
 use time::precise_time_ns;
-use webrender_api::ImageKey;
+use webrender_api::{ImageData, ImageDescriptor, ImageKey};
 
 pub mod blob_url_store;
 pub mod filemanager_thread;
@@ -777,7 +777,7 @@ pub fn http_percent_encode(bytes: &[u8]) -> String {
 
 #[derive(Deserialize, Serialize)]
 pub enum WebrenderImageMsg {
-    UpdateResources(Vec<webrender_api::ResourceUpdate>),
+    AddImage(ImageKey, ImageDescriptor, ImageData),
     GenerateImageKey(IpcSender<ImageKey>),
 }
 
@@ -797,8 +797,11 @@ impl WebrenderIpcSender {
         receiver.recv().expect("error receiving image key result")
     }
 
-    pub fn update_resources(&self, updates: Vec<webrender_api::ResourceUpdate>) {
+    pub fn add_image(&self, key: ImageKey, descriptor: ImageDescriptor, data: ImageData) {
-        if let Err(e) = self.0.send(WebrenderImageMsg::UpdateResources(updates)) {
+        if let Err(e) = self
+            .0
+            .send(WebrenderImageMsg::AddImage(key, descriptor, data))
+        {
             warn!("Error sending image update: {}", e);
         }
     }

components/script/dom/htmlmediaelement.rs

@@ -81,7 +81,7 @@ use net_traits::request::{Destination, Referrer};
 use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, Metadata};
 use net_traits::{NetworkError, ResourceFetchTiming, ResourceTimingType};
 use script_layout_interface::HTMLMediaData;
-use script_traits::WebrenderIpcSender;
+use script_traits::{ImageUpdate, WebrenderIpcSender};
 use servo_config::pref;
 use servo_media::player::audio::AudioRenderer;
 use servo_media::player::video::{VideoFrame, VideoFrameRenderer};
@@ -95,9 +95,9 @@ use std::mem;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use time::{self, Duration, Timespec};
+use webrender_api::ImageKey;
 use webrender_api::{ExternalImageData, ExternalImageId, ExternalImageType, TextureTarget};
 use webrender_api::{ImageData, ImageDescriptor, ImageDescriptorFlags, ImageFormat};
-use webrender_api::{ImageKey, Transaction};
 
 #[derive(PartialEq)]
 enum FrameStatus {
@@ -177,10 +177,10 @@ impl MediaFrameRenderer {
 
 impl VideoFrameRenderer for MediaFrameRenderer {
     fn render(&mut self, frame: VideoFrame) {
-        let mut txn = Transaction::new();
+        let mut updates = vec![];
 
         if let Some(old_image_key) = mem::replace(&mut self.very_old_frame, self.old_frame.take()) {
-            txn.delete_image(old_image_key);
+            updates.push(ImageUpdate::DeleteImage(old_image_key));
         }
 
         let descriptor = ImageDescriptor::new(
@@ -195,12 +195,11 @@ impl VideoFrameRenderer for MediaFrameRenderer {
                 if *width == frame.get_width() && *height == frame.get_height() =>
             {
                 if !frame.is_gl_texture() {
-                    txn.update_image(
+                    updates.push(ImageUpdate::UpdateImage(
                         *image_key,
                         descriptor,
                         ImageData::Raw(frame.get_data()),
-                        &webrender_api::DirtyRect::All,
+                    ));
-                    );
                 }
 
                 self.current_frame_holder
@@ -208,7 +207,7 @@ impl VideoFrameRenderer for MediaFrameRenderer {
                     .set(frame);
 
                 if let Some(old_image_key) = self.old_frame.take() {
-                    txn.delete_image(old_image_key);
+                    updates.push(ImageUpdate::DeleteImage(old_image_key));
                 }
             }
             Some((ref mut image_key, ref mut width, ref mut height)) => {
@@ -241,7 +240,7 @@ impl VideoFrameRenderer for MediaFrameRenderer {
                     .get_or_insert_with(|| FrameHolder::new(frame.clone()))
                     .set(frame);
 
-                txn.add_image(new_image_key, descriptor, image_data, None);
+                updates.push(ImageUpdate::AddImage(new_image_key, descriptor, image_data));
             },
             None => {
                 let image_key = self.api.generate_image_key();
@@ -265,10 +264,10 @@ impl VideoFrameRenderer for MediaFrameRenderer {
 
                 self.current_frame_holder = Some(FrameHolder::new(frame));
 
-                txn.add_image(image_key, descriptor, image_data, None);
+                updates.push(ImageUpdate::AddImage(image_key, descriptor, image_data));
             },
         }
-        self.api.update_resources(txn.resource_updates);
+        self.api.update_images(updates);
     }
 }
 

components/script_traits/lib.rs

@@ -69,8 +69,11 @@ use style_traits::SpeculativePainter;
 use webrender_api::units::{
     DeviceIntSize, DevicePixel, LayoutPixel, LayoutPoint, LayoutSize, WorldPoint,
 };
-use webrender_api::{BuiltDisplayList, DocumentId, ExternalScrollId, ImageKey, ScrollClamping};
+use webrender_api::{
-use webrender_api::{BuiltDisplayListDescriptor, HitTestFlags, HitTestResult, ResourceUpdate};
+    BuiltDisplayList, DocumentId, ExternalScrollId, ImageData, ImageDescriptor, ImageKey,
+    ScrollClamping,
+};
+use webrender_api::{BuiltDisplayListDescriptor, HitTestFlags, HitTestResult};
 
 pub use crate::script_msg::{
     DOMMessage, HistoryEntryReplacement, SWManagerMsg, SWManagerSenders, ScopeThings,
@@ -1118,7 +1121,7 @@ pub enum WebrenderMsg {
     /// provided channel sender.
     GenerateImageKey(IpcSender<ImageKey>),
     /// Perform a resource update operation.
-    UpdateResources(Vec<ResourceUpdate>),
+    UpdateImages(Vec<ImageUpdate>),
 }
 
 #[derive(Clone, Deserialize, Serialize)]
@@ -1210,9 +1213,20 @@ impl WebrenderIpcSender {
     }
 
     /// Perform a resource update operation.
-    pub fn update_resources(&self, updates: Vec<ResourceUpdate>) {
+    pub fn update_images(&self, updates: Vec<ImageUpdate>) {
-        if let Err(e) = self.0.send(WebrenderMsg::UpdateResources(updates)) {
+        if let Err(e) = self.0.send(WebrenderMsg::UpdateImages(updates)) {
-            warn!("error sending resource updates: {}", e);
+            warn!("error sending image updates: {}", e);
         }
     }
 }
+
+#[derive(Deserialize, Serialize)]
+/// Serializable image updates that must be performed by WebRender.
+pub enum ImageUpdate {
+    /// Register a new image.
+    AddImage(ImageKey, ImageDescriptor, ImageData),
+    /// Delete a previously registered image registration.
+    DeleteImage(ImageKey),
+    /// Update an existing image registration.
+    UpdateImage(ImageKey, ImageDescriptor, ImageData),
+}

components/servo/Cargo.toml

@@ -54,7 +54,7 @@ embedder_traits = {path = "../embedder_traits"}
 env_logger = "0.7"
 euclid = "0.20"
 gfx = {path = "../gfx"}
-gleam = "0.9"
+gleam = "0.11"
 ipc-channel = "0.14"
 keyboard-types = "0.4"
 layout_thread_2013 = {path = "../layout_thread", optional = true}

components/servo/lib.rs

@@ -400,14 +400,6 @@ where
         let viewport_size = coordinates.viewport.size.to_f32() / device_pixel_ratio;
 
         let (mut webrender, webrender_api_sender) = {
-            let recorder = if opts.webrender_record {
-                let record_path = PathBuf::from("wr-record.bin");
-                let recorder = Box::new(webrender::BinaryRecorder::new(&record_path));
-                Some(recorder as Box<dyn webrender::ApiRecordingReceiver>)
-            } else {
-                None
-            };
-
             let mut debug_flags = webrender::DebugFlags::empty();
             debug_flags.set(webrender::DebugFlags::PROFILER_DBG, opts.webrender_stats);
 
@@ -424,7 +416,6 @@ where
                     resource_override_path: opts.shaders_dir.clone(),
                     enable_aa: opts.enable_text_antialiasing,
                     debug_flags: debug_flags,
-                    recorder: recorder,
                     precache_flags: if opts.precache_shaders {
                         ShaderPrecacheFlags::FULL_COMPILE
                     } else {
@@ -465,6 +456,7 @@ where
             webrender_gl.clone(),
             &mut webrender,
             webrender_api_sender.clone(),
+            webrender_document,
             &mut webxr_main_thread,
             &mut external_image_handlers,
             external_images.clone(),
@@ -891,6 +883,7 @@ fn create_constellation(
     let font_cache_thread = FontCacheThread::new(
         public_resource_threads.sender(),
         webrender_api_sender.create_api(),
+        webrender_document,
     );
 
     let initial_state = InitialConstellationState {
@@ -1052,6 +1045,7 @@ fn create_webgl_threads(
     webrender_gl: Rc<dyn gl::Gl>,
     webrender: &mut webrender::Renderer,
     webrender_api_sender: webrender_api::RenderApiSender,
+    webrender_doc: webrender_api::DocumentId,
     webxr_main_thread: &mut webxr::MainThreadRegistry,
     external_image_handlers: &mut WebrenderExternalImageHandlers,
     external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@@ -1075,6 +1069,7 @@ fn create_webgl_threads(
         webrender_surfman,
         webrender_gl,
         webrender_api_sender,
+        webrender_doc,
         external_images,
         gl_type,
     );

components/webgpu/Cargo.toml

@@ -17,5 +17,5 @@ log = "0.4"
 malloc_size_of = { path = "../malloc_size_of" }
 serde = "1.0"
 servo_config = {path = "../config"}
-smallvec = "0.6"
+smallvec = { version = "0.6", features = ["serde"] }
 wgpu-core = { version = "0.1.0", git = "https://github.com/gfx-rs/wgpu", features = ["serde"] }

tests/wpt/metadata/css/css-images/gradient-move-stops.html.ini

@@ -1,3 +0,0 @@
-[gradient-move-stops.html]
-  type: reftest
-  expected: FAIL

tests/wpt/metadata/css/css-transforms/transform-input-012.html.ini

@@ -1,4 +1,3 @@
 [transform-input-012.html]
   bug: https://github.com/servo/servo/issues/21092
-  expected:
+  expected: FAIL
-    if os == "linux": FAIL

tests/wpt/metadata/html/rendering/non-replaced-elements/the-fieldset-and-legend-elements/fieldset-transform-translatez.html.ini

@@ -0,0 +1,3 @@
+[fieldset-transform-translatez.html]
+  expected:
+    if os == "linux": FAIL