Backed out 2 changesets (bug 1492389) for causing perma reftest failures at tests/reftest/tests/layout/reftests/transform-3d/1035611-1-ref.html a=backout
authorCoroiu Cristina <ccoroiu@mozilla.com>
Thu, 20 Sep 2018 09:47:22 +0300
changeset 437377 08592337ced1b16cdea73ea94fdb0af9c8927b31
parent 437376 08a77a40e658c82b7003c125d2bc69800fc6417d
child 437390 d51a5d2bc3a9daf39e9eb8812ce091e411f601ab
child 437417 151a0a8b9ea1c8a54ff1b65ef9455079683528d0
push id34680
push userccoroiu@mozilla.com
push dateThu, 20 Sep 2018 06:47:52 +0000
treeherdermozilla-central@08592337ced1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1492389, 1035611
milestone64.0a1
backs out16995931c819acec7bbf665fe635da7430602c85
592121f27afe3d1b5ae7823caa1725b0bf81a3b0
first release with
nightly linux32
08592337ced1 / 64.0a1 / 20180920100522 / files
nightly linux64
08592337ced1 / 64.0a1 / 20180920100522 / files
nightly mac
08592337ced1 / 64.0a1 / 20180920100522 / files
nightly win32
08592337ced1 / 64.0a1 / 20180920100522 / files
nightly win64
08592337ced1 / 64.0a1 / 20180920100522 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 2 changesets (bug 1492389) for causing perma reftest failures at tests/reftest/tests/layout/reftests/transform-3d/1035611-1-ref.html a=backout Backed out changeset 16995931c819 (bug 1492389) Backed out changeset 592121f27afe (bug 1492389)
gfx/webrender/res/brush.glsl
gfx/webrender/res/prim_shared.glsl
gfx/webrender/res/ps_split_composite.glsl
gfx/webrender/res/ps_text_run.glsl
gfx/webrender/src/clip.rs
gfx/webrender/src/render_task.rs
gfx/webrender_api/src/image.rs
gfx/webrender_bindings/revision.txt
gfx/wrench/src/yaml_frame_reader.rs
layout/reftests/box-shadow/reftest.list
layout/reftests/transform-3d/reftest.list
--- a/gfx/webrender/res/brush.glsl
+++ b/gfx/webrender/res/brush.glsl
@@ -86,17 +86,16 @@ void main(void) {
     // out clip information.
     // TODO(gw): It's possible that we might want alpha
     //           shaders that don't clip in the future,
     //           but it's reasonable to assume that one
     //           implies the other, for now.
 #ifdef WR_FEATURE_ALPHA_PASS
     write_clip(
         vi.world_pos,
-        vi.snap_offset,
         clip_area
     );
 #endif
 
     // Run the specific brush VS code to write interpolators.
     brush_vs(
         vi,
         ph.specific_prim_address,
--- a/gfx/webrender/res/prim_shared.glsl
+++ b/gfx/webrender/res/prim_shared.glsl
@@ -22,17 +22,16 @@ uniform sampler2DArray sCacheRGBA8;
 uniform sampler2DArray sSharedCacheA8;
 
 vec2 clamp_rect(vec2 pt, RectWithSize rect) {
     return clamp(pt, rect.p0, rect.p0 + rect.size);
 }
 
 // TODO: convert back to RectWithEndPoint if driver issues are resolved, if ever.
 flat varying vec4 vClipMaskUvBounds;
-flat varying vec4 vClipMaskUvSampleBounds;
 // XY and W are homogeneous coordinates, Z is the layer index
 varying vec4 vClipMaskUv;
 
 
 #ifdef WR_VERTEX_SHADER
 
 #define COLOR_MODE_FROM_PASS          0
 #define COLOR_MODE_ALPHA              1
@@ -218,31 +217,24 @@ VertexInfo write_transform_vertex(RectWi
         local_pos,
         vec2(0.0),
         world_pos
     );
 
     return vi;
 }
 
-void write_clip(vec4 world_pos, vec2 snap_offset, ClipArea area) {
+void write_clip(vec4 world_pos, ClipArea area) {
     vec2 uv = world_pos.xy * uDevicePixelRatio +
-        world_pos.w * (snap_offset + area.common_data.task_rect.p0 - area.screen_origin);
+        world_pos.w * (area.common_data.task_rect.p0 - area.screen_origin);
     vClipMaskUvBounds = vec4(
         area.common_data.task_rect.p0,
         area.common_data.task_rect.p0 + area.common_data.task_rect.size
     );
-    vClipMaskUvSampleBounds.xy = vClipMaskUvBounds.xy + vec2(0.5);
-    vClipMaskUvSampleBounds.zw = vClipMaskUvBounds.zw - vec2(0.5);
     vClipMaskUv = vec4(uv, area.common_data.texture_layer_index, world_pos.w);
-
-    vec2 texture_size = vec2(textureSize(sCacheA8, 0).xy);
-    vClipMaskUv.xy /= texture_size;
-    vClipMaskUvBounds /= texture_size.xyxy;
-    vClipMaskUvSampleBounds /= texture_size.xyxy;
 }
 #endif //WR_VERTEX_SHADER
 
 #ifdef WR_FRAGMENT_SHADER
 
 float do_clip() {
     // check for the dummy bounds, which are given to the opaque objects
     if (vClipMaskUvBounds.xy == vClipMaskUvBounds.zw) {
@@ -253,24 +245,19 @@ float do_clip() {
     vec2 mask_uv = vClipMaskUv.xy * gl_FragCoord.w;
     bvec4 inside = lessThanEqual(
         vec4(vClipMaskUvBounds.xy, mask_uv),
         vec4(mask_uv, vClipMaskUvBounds.zw));
     // bail out if the pixel is outside the valid bounds
     if (!all(inside)) {
         return 0.0;
     }
-
     // finally, the slow path - fetch the mask value from an image
-
-    // TODO(gw): texelFetch here fails on some nVidia hardware in
-    //           some cases. For now, just use texture()
-    //           unconditionally.
-    mask_uv = clamp(mask_uv, vClipMaskUvSampleBounds.xy, vClipMaskUvSampleBounds.zw);
-    return texture(sCacheA8, vec3(mask_uv, vClipMaskUv.z)).r;
+    ivec3 tc = ivec3(mask_uv, vClipMaskUv.z);
+    return texelFetch(sCacheA8, tc, 0).r;
 }
 
 #ifdef WR_FEATURE_DITHERING
 vec4 dither(vec4 color) {
     const int matrix_mask = 7;
 
     ivec2 pos = ivec2(gl_FragCoord.xy) & ivec2(matrix_mask);
     float noise_normalized = (texelFetch(sDither, pos, 0).r * 255.0 + 0.5) / 64.0;
--- a/gfx/webrender/res/ps_split_composite.glsl
+++ b/gfx/webrender/res/ps_split_composite.glsl
@@ -75,17 +75,16 @@ void main(void) {
     vec4 final_pos = vec4(
         dest_origin * world_pos.w + world_pos.xy * uDevicePixelRatio,
         world_pos.w * ci.z,
         world_pos.w
     );
 
     write_clip(
         world_pos,
-        vec2(0.0),
         clip_area
     );
 
     gl_Position = uTransform * final_pos;
 
     vec2 texture_size = vec2(textureSize(sCacheRGBA8, 0));
     vec2 uv0 = res.uv_rect.p0;
     vec2 uv1 = res.uv_rect.p1;
--- a/gfx/webrender/res/ps_text_run.glsl
+++ b/gfx/webrender/res/ps_text_run.glsl
@@ -224,17 +224,17 @@ void main(void) {
 
 #ifdef WR_FEATURE_GLYPH_TRANSFORM
     vec2 f = (glyph_transform * vi.local_pos - glyph_rect.p0) / glyph_rect.size;
     vUvClip = vec4(f, 1.0 - f);
 #else
     vec2 f = (vi.local_pos - glyph_rect.p0) / glyph_rect.size;
 #endif
 
-    write_clip(vi.world_pos, vi.snap_offset, clip_area);
+    write_clip(vi.world_pos, clip_area);
 
     switch (color_mode) {
         case COLOR_MODE_ALPHA:
         case COLOR_MODE_BITMAP:
             vMaskSwizzle = vec2(0.0, 1.0);
             vColor = text.color;
             break;
         case COLOR_MODE_SUBPX_BG_PASS2:
--- a/gfx/webrender/src/clip.rs
+++ b/gfx/webrender/src/clip.rs
@@ -101,17 +101,16 @@ enum ClipResult {
     // require a clip mask, depending on other factors.
     Partial,
 }
 
 // A clip node is a single clip source, along with some
 // positioning information and implementation details
 // that control where the GPU data for this clip source
 // can be found.
-#[derive(Debug)]
 pub struct ClipNode {
     pub item: ClipItem,
     pub gpu_cache_handle: GpuCacheHandle,
 }
 
 // Flags that are attached to instances of clip nodes.
 bitflags! {
     pub struct ClipNodeFlags: u8 {
@@ -761,24 +760,21 @@ impl ClipItem {
                 orientation,
                 wavy_line_thickness,
             }
         )
     }
 
     pub fn new_box_shadow(
         shadow_rect: LayoutRect,
-        mut shadow_radius: BorderRadius,
+        shadow_radius: BorderRadius,
         prim_shadow_rect: LayoutRect,
         blur_radius: f32,
         clip_mode: BoxShadowClipMode,
     ) -> Self {
-        // Make sure corners don't overlap.
-        ensure_no_corner_overlap(&mut shadow_radius, &shadow_rect);
-
         // Get the fractional offsets required to match the
         // source rect with a minimal rect.
         let fract_offset = LayoutPoint::new(
             shadow_rect.origin.x.fract().abs(),
             shadow_rect.origin.y.fract().abs(),
         );
         let fract_size = LayoutSize::new(
             shadow_rect.size.width.fract().abs(),
--- a/gfx/webrender/src/render_task.rs
+++ b/gfx/webrender/src/render_task.rs
@@ -735,17 +735,17 @@ impl RenderTask {
         };
 
         let (mut target_rect, target_index) = self.get_target_rect();
         // The primitives inside a fixed-location render task
         // are already placed to their corresponding positions,
         // so the shader doesn't need to shift by the origin.
         if let RenderTaskLocation::Fixed(_) = self.location {
             target_rect.origin = DeviceIntPoint::origin();
-        }
+        };
 
         RenderTaskData {
             data: [
                 target_rect.origin.x as f32,
                 target_rect.origin.y as f32,
                 target_rect.size.width as f32,
                 target_rect.size.height as f32,
                 target_index.0 as f32,
--- a/gfx/webrender_api/src/image.rs
+++ b/gfx/webrender_api/src/image.rs
@@ -1,155 +1,95 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#![deny(missing_docs)]
-
 extern crate serde_bytes;
 
 use font::{FontInstanceKey, FontInstanceData, FontKey, FontTemplate};
 use std::sync::Arc;
 use {DevicePoint, DeviceUintPoint, DeviceUintRect, DeviceUintSize};
 use {IdNamespace, TileOffset, TileSize};
 use euclid::size2;
 
-/// An opaque identifier describing an image registered with WebRender.
-/// This is used as a handle to reference images, and is used as the
-/// hash map key for the actual image storage in the `ResourceCache`.
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub struct ImageKey(pub IdNamespace, pub u32);
 
 impl ImageKey {
-    /// Placeholder Image key, used to represent None.
     pub const DUMMY: Self = ImageKey(IdNamespace(0), 0);
 
-    /// Mints a new ImageKey. The given ID must be unique.
     pub fn new(namespace: IdNamespace, key: u32) -> Self {
         ImageKey(namespace, key)
     }
 }
 
 /// An arbitrary identifier for an external image provided by the
 /// application. It must be a unique identifier for each external
 /// image.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub struct ExternalImageId(pub u64);
 
-/// Specifies the type of texture target in driver terms.
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub enum TextureTarget {
-    /// Standard texture. This maps to GL_TEXTURE_2D in OpenGL.
     Default = 0,
-    /// Array texture. This maps to GL_TEXTURE_2D_ARRAY in OpenGL. See
-    /// https://www.khronos.org/opengl/wiki/Array_Texture for background
-    /// on Array textures.
     Array = 1,
-    /// Rectange texture. This maps to GL_TEXTURE_RECTANGLE in OpenGL. This
-    /// is similar to a standard texture, with a few subtle differences
-    /// (no mipmaps, non-power-of-two dimensions, different coordinate space)
-    /// that make it useful for representing the kinds of textures we use
-    /// in WebRender. See https://www.khronos.org/opengl/wiki/Rectangle_Texture
-    /// for background on Rectangle textures.
     Rect = 2,
-    /// External texture. This maps to GL_TEXTURE_EXTERNAL_OES in OpenGL, which
-    /// is an extension. This is used for image formats that OpenGL doesn't
-    /// understand, particularly YUV. See
-    /// https://www.khronos.org/registry/OpenGL/extensions/OES/OES_EGL_image_external.txt
     External = 3,
 }
 
-/// Storage format identifier for externally-managed images.
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub enum ExternalImageType {
-    /// The image is texture-backed.
     TextureHandle(TextureTarget),
-    /// The image is heap-allocated by the embedding.
     Buffer,
 }
 
-/// Descriptor for external image resources. See `ImageData`.
 #[repr(C)]
 #[derive(Debug, Copy, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct ExternalImageData {
-    /// The identifier of this external image, provided by the embedding.
     pub id: ExternalImageId,
-    /// For multi-plane images (i.e. YUV), indicates the plane of the
-    /// original image that this struct represents. 0 for single-plane images.
     pub channel_index: u8,
-    /// Storage format identifier.
     pub image_type: ExternalImageType,
 }
 
-/// Specifies the format of a series of pixels, in driver terms.
 #[repr(u32)]
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub enum ImageFormat {
-    /// One-channel, byte storage. The "red" doesn't map to the color
-    /// red per se, and is just the way that OpenGL has historically referred
-    /// to single-channel buffers.
     R8 = 1,
-    /// Four channels, byte storage.
     BGRA8 = 3,
-    /// Four channels, float storage.
     RGBAF32 = 4,
-    /// Two-channels, byte storage. Similar to `R8`, this just means
-    /// "two channels" rather than "red and green".
     RG8 = 5,
-    /// Four channels, signed integer storage.
     RGBAI32 = 6,
 }
 
 impl ImageFormat {
-    /// Returns the number of bytes per pixel for the given format.
     pub fn bytes_per_pixel(self) -> u32 {
         match self {
             ImageFormat::R8 => 1,
             ImageFormat::BGRA8 => 4,
             ImageFormat::RGBAF32 => 16,
             ImageFormat::RG8 => 2,
             ImageFormat::RGBAI32 => 16,
         }
     }
 }
 
-/// Metadata (but not storage) describing an image In WebRender.
 #[derive(Copy, Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ImageDescriptor {
-    /// Format of the image data.
     pub format: ImageFormat,
-    /// Width and length of the image data, in pixels.
     pub size: DeviceUintSize,
-    /// The number of bytes from the start of one row to the next. If non-None,
-    /// `compute_stride` will return this value, otherwise it returns
-    /// `width * bpp`. Different source of images have different alignment
-    /// constraints for rows, so the stride isn't always equal to width * bpp.
     pub stride: Option<u32>,
-    /// Offset in bytes of the first pixel of this image in its backing buffer.
-    /// This is used for tiling, wherein WebRender extracts chunks of input images
-    /// in order to cache, manipulate, and render them individually. This offset
-    /// tells the texture upload machinery where to find the bytes to upload for
-    /// this tile. Non-tiled images generally set this to zero.
     pub offset: u32,
-    /// Whether this image is opaque, or has an alpha channel. Avoiding blending
-    /// for opaque surfaces is an important optimization.
     pub is_opaque: bool,
-    /// Whether to allow the driver to automatically generate mipmaps. If images
-    /// are already downscaled appropriately, mipmap generation can be wasted
-    /// work, and cause performance problems on some cards/drivers.
-    ///
-    /// See https://github.com/servo/webrender/pull/2555/
     pub allow_mipmaps: bool,
 }
 
 impl ImageDescriptor {
-    /// Mints a new ImageDescriptor.
     pub fn new(
         width: u32,
         height: u32,
         format: ImageFormat,
         is_opaque: bool,
         allow_mipmaps: bool,
     ) -> Self {
         ImageDescriptor {
@@ -157,48 +97,36 @@ impl ImageDescriptor {
             format,
             stride: None,
             offset: 0,
             is_opaque,
             allow_mipmaps,
         }
     }
 
-    /// Returns the stride, either via an explicit stride stashed on the object
-    /// or by the default computation.
     pub fn compute_stride(&self) -> u32 {
         self.stride.unwrap_or(self.size.width * self.format.bytes_per_pixel())
     }
 
-    /// Computes the total size of the image, in bytes.
     pub fn compute_total_size(&self) -> u32 {
         self.compute_stride() * self.size.height
     }
 
-    /// Computes the bounding rectangle for the image, rooted at (0, 0).
     pub fn full_rect(&self) -> DeviceUintRect {
         DeviceUintRect::new(
             DeviceUintPoint::zero(),
             self.size,
         )
     }
 }
 
-/// Represents the backing store of an arbitrary series of pixels for display by
-/// WebRender. This storage can take several forms.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum ImageData {
-    /// A simple series of bytes, provided by the embedding and owned by WebRender.
-    /// The format is stored out-of-band, currently in ImageDescriptor.
     Raw(#[serde(with = "serde_image_data_raw")] Arc<Vec<u8>>),
-    /// An series of commands that can be rasterized into an image via an
-    /// embedding-provided callback.
     Blob(#[serde(with = "serde_image_data_raw")] Arc<BlobImageData>),
-    /// An image owned by the embedding, and referenced by WebRender. This may
-    /// take the form of a texture or a heap-allocated buffer.
     External(ExternalImageData),
 }
 
 mod serde_image_data_raw {
     extern crate serde_bytes;
 
     use std::sync::Arc;
     use serde::{Deserializer, Serializer};
@@ -208,62 +136,53 @@ mod serde_image_data_raw {
     }
 
     pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Arc<Vec<u8>>, D::Error> {
         serde_bytes::deserialize(deserializer).map(Arc::new)
     }
 }
 
 impl ImageData {
-    /// Mints a new raw ImageData, taking ownership of the bytes.
     pub fn new(bytes: Vec<u8>) -> Self {
         ImageData::Raw(Arc::new(bytes))
     }
 
-    /// Mints a new raw ImageData from Arc-ed bytes.
     pub fn new_shared(bytes: Arc<Vec<u8>>) -> Self {
         ImageData::Raw(bytes)
     }
 
-    /// Mints a new Blob ImageData.
     pub fn new_blob_image(commands: BlobImageData) -> Self {
         ImageData::Blob(Arc::new(commands))
     }
 
-    /// Returns true if this ImageData represents a blob.
     #[inline]
     pub fn is_blob(&self) -> bool {
         match *self {
             ImageData::Blob(_) => true,
             _ => false,
         }
     }
 
-    /// Returns true if this variant of ImageData should go through the texture
-    /// cache.
     #[inline]
     pub fn uses_texture_cache(&self) -> bool {
         match *self {
             ImageData::External(ref ext_data) => match ext_data.image_type {
                 ExternalImageType::TextureHandle(_) => false,
                 ExternalImageType::Buffer => true,
             },
             ImageData::Blob(_) => true,
             ImageData::Raw(_) => true,
         }
     }
 }
 
 /// The resources exposed by the resource cache available for use by the blob rasterizer.
 pub trait BlobImageResources {
-    /// Returns the `FontTemplate` for the given key.
     fn get_font_data(&self, key: FontKey) -> &FontTemplate;
-    /// Returns the `FontInstanceData` for the given key, if found.
     fn get_font_instance_data(&self, key: FontInstanceKey) -> Option<FontInstanceData>;
-    /// Returns the image metadata and backing store for the given key, if found.
     fn get_image(&self, key: ImageKey) -> Option<(&ImageData, &ImageDescriptor)>;
 }
 
 /// A handler on the render backend that can create rasterizer objects which will
 /// be sent to the scene builder thread to execute the rasterization.
 ///
 /// The handler is responsible for collecting resources, managing/updating blob commands
 /// and creating the rasterizer objects, but isn't expected to do any rasterization itself.
@@ -298,77 +217,49 @@ pub trait BlobImageHandler: Send {
 
     /// A hook to let the handler clean up any state related a given namespace before the
     /// resource cache deletes them.
     fn clear_namespace(&mut self, namespace: IdNamespace);
 }
 
 /// A group of rasterization requests to execute synchronously on the scene builder thread.
 pub trait AsyncBlobImageRasterizer : Send {
-    /// Rasterize the requests.
     fn rasterize(&mut self, requests: &[BlobImageParams]) -> Vec<(BlobImageRequest, BlobImageResult)>;
 }
 
 
-/// Input parameters for the BlobImageRasterizer.
 #[derive(Copy, Clone, Debug)]
 pub struct BlobImageParams {
-    /// A key that identifies the blob image rasterization request.
     pub request: BlobImageRequest,
-    /// Description of the format of the blob's output image.
     pub descriptor: BlobImageDescriptor,
-    /// An optional sub-rectangle of the image to avoid re-rasterizing
-    /// the entire image when only a portion is updated.
-    ///
-    /// If set to None the entire image is rasterized.
     pub dirty_rect: Option<DeviceUintRect>,
 }
 
-/// Backing store for blob image command streams.
 pub type BlobImageData = Vec<u8>;
 
-/// Result type for blob raserization.
 pub type BlobImageResult = Result<RasterizedBlobImage, BlobImageError>;
 
-/// Metadata (but not storage) for a blob image.
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct BlobImageDescriptor {
-    /// Size in device pixels of the blob's output image.
     pub size: DeviceUintSize,
-    /// When tiling, offset point in device pixels of this tile in the full
-    /// image. Generally (0, 0) outside of tiling.
     pub offset: DevicePoint,
-    /// Format for the data in the backing store.
     pub format: ImageFormat,
 }
 
-/// Representation of a rasterized blob image. This is obtained by passing
-/// `BlobImageData` to the embedding via the rasterization callback.
 pub struct RasterizedBlobImage {
-    /// The bounding rectangle for this bob image.
     pub rasterized_rect: DeviceUintRect,
-    /// Backing store. The format is stored out of band in `BlobImageDescriptor`.
     pub data: Arc<Vec<u8>>,
 }
 
-/// Error code for when blob rasterization failed.
 #[derive(Clone, Debug)]
 pub enum BlobImageError {
-    /// Out of memory.
     Oom,
-    /// Other failure, embedding-specified.
+    InvalidKey,
+    InvalidData,
     Other(String),
 }
 
-
-
-/// A key identifying blob image rasterization work requested from the blob
-/// image rasterizer.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct BlobImageRequest {
-    /// Unique handle to the image.
     pub key: ImageKey,
-    /// Tiling offset in number of tiles, if applicable.
-    ///
-    /// `None` if the image will not be tiled.
     pub tile: Option<TileOffset>,
 }
--- a/gfx/webrender_bindings/revision.txt
+++ b/gfx/webrender_bindings/revision.txt
@@ -1,1 +1,1 @@
-3104734e8927d25b7ef81c6be021bb9337718720
+5b5b4145ecef117acb02fd1f9b72bf02e85c650b
--- a/gfx/wrench/src/yaml_frame_reader.rs
+++ b/gfx/wrench/src/yaml_frame_reader.rs
@@ -1540,17 +1540,17 @@ impl YamlFrameReader {
                 Some(make_perspective(perspective_origin, value as f32))
             }
             Some(_) => None,
             _ => yaml["perspective"].as_matrix4d(),
         };
 
         let reference_frame_id = dl.push_reference_frame(info, transform.into(), perspective);
 
-        let numeric_id = yaml["id"].as_i64();
+        let numeric_id = yaml["reference-frame-id"].as_i64();
         if let Some(numeric_id) = numeric_id {
             self.add_clip_id_mapping(numeric_id as u64, reference_frame_id);
         }
 
         reference_frame_id
     }
 
     pub fn handle_reference_frame(
--- a/layout/reftests/box-shadow/reftest.list
+++ b/layout/reftests/box-shadow/reftest.list
@@ -17,17 +17,17 @@ fails-if(Android) == boxshadow-fileuploa
 fuzzy-if(/^Windows\x20NT\x2010\.0/.test(http.oscpu),0-98,0-152) fuzzy-if(skiaContent,0-13,0-28) fuzzy-if(webrender,19-19,50-50) == boxshadow-inner-basic.html boxshadow-inner-basic-ref.svg
 fuzzy-if(skiaContent,0-1,0-17) random-if(layersGPUAccelerated) == boxshadow-mixed.html boxshadow-mixed-ref.html
 fuzzy-if(skiaContent,0-1,0-17) == boxshadow-mixed-2.html boxshadow-mixed-2-ref.html
 random-if(d2d) fuzzy-if(skiaContent,0-1,0-212) fuzzy-if(webrender,0-127,0-3528) == boxshadow-rounded-spread.html boxshadow-rounded-spread-ref.html
 fuzzy-if(skiaContent,0-1,0-50) == boxshadow-dynamic.xul boxshadow-dynamic-ref.xul
 random-if(d2d) fuzzy-if(skiaContent,0-1,0-14) == boxshadow-onecorner.html boxshadow-onecorner-ref.html
 random-if(d2d) fuzzy-if(skiaContent,0-1,0-22) == boxshadow-twocorners.html boxshadow-twocorners-ref.html
 random-if(d2d) fuzzy-if(skiaContent,0-1,0-36) == boxshadow-threecorners.html boxshadow-threecorners-ref.html
-fuzzy(0-2,0-440) fails-if(webrender&&gtkWidget) == boxshadow-skiprect.html boxshadow-skiprect-ref.html
+fuzzy(0-2,0-440) fails-if(webrender) == boxshadow-skiprect.html boxshadow-skiprect-ref.html
 == boxshadow-opacity.html boxshadow-opacity-ref.html
 == boxshadow-color-rounding.html boxshadow-color-rounding-ref.html
 == boxshadow-color-rounding-middle.html boxshadow-color-rounding-middle-ref.html
 fuzzy(0-3,0-500) fuzzy-if(d2d,0-2,0-1080) == boxshadow-border-radius-int.html boxshadow-border-radius-int-ref.html
 == boxshadow-inset-neg-spread.html about:blank
 == boxshadow-inset-neg-spread2.html boxshadow-inset-neg-spread2-ref.html
 fuzzy(0-26,0-3610) fuzzy-if(d2d,0-26,0-5910) == boxshadow-rotated.html boxshadow-rotated-ref.html # Bug 1211264
 == boxshadow-inset-large-border-radius.html boxshadow-inset-large-border-radius-ref.html
--- a/layout/reftests/transform-3d/reftest.list
+++ b/layout/reftests/transform-3d/reftest.list
@@ -57,17 +57,17 @@ fuzzy-if(winWidget&&!layersGPUAccelerate
 # Different, but equivalent (for the given transform) transform origins
 fuzzy-if(webrender,0-1,0-4) == rotatex-transformorigin-1a.html rotatex-transformorigin-1-ref.html
 fuzzy-if((gtkWidget&&layersOMTC)||(winWidget&&!layersGPUAccelerated),0-1,0-86) == overflow-hidden-1a.html overflow-hidden-1-ref.html
 fails-if(webrender) == transform-style-flat-1a.html transform-style-flat-1-ref.html
 == willchange-containing-block.html?willchange willchange-containing-block.html?ref
 != willchange-containing-block.html?willchange willchange-containing-block.html?noblock
 fuzzy-if(winWidget&&!layersGPUAccelerated,0-1,0-606) == scroll-perspective-1.html scroll-perspective-1-ref.html
 # Bugs
-fails-if(!layersGPUAccelerated) fuzzy-if(winWidget&&webrender,5-5,71-71) == 1035611-1.html 1035611-1-ref.html # Bug 1072898 for !layersGPUAccelerated failures
+fails-if(!layersGPUAccelerated) == 1035611-1.html 1035611-1-ref.html # Bug 1072898 for !layersGPUAccelerated failures
 != 1157984-1.html about:blank # Bug 1157984
 fuzzy(0-3,0-99) == animate-cube-radians.html animate-cube-radians-ref.html # subpixel AA
 fuzzy(0-3,0-99) fuzzy-if(/^Windows\x20NT\x206\.1/.test(http.oscpu)&&!layersGPUAccelerated,0-16,0-6) == animate-cube-radians-zoom.html animate-cube-radians-zoom-ref.html
 != animate-cube-radians-ref.html animate-cube-radians-zoom-ref.html
 fuzzy(0-3,0-99) == animate-cube-degrees.html animate-cube-degrees-ref.html # subpixel AA
 == animate-cube-degrees-zoom.html animate-cube-degrees-zoom-ref.html
 != animate-cube-degrees-ref.html animate-cube-degrees-zoom-ref.html
 fuzzy-if(gtkWidget,0-128,0-100) fuzzy-if(Android||OSX==1010||(gtkWidget&&layersGPUAccelerated),0-143,0-100) fuzzy-if(winWidget||OSX<1010,0-141,0-100) == preserves3d-nested.html preserves3d-nested-ref.html