Use clip rect normalized to prim origin, to fix interning with baked …

…scroll offsets.

webrender/src/display_list_flattener.rs

@@ -324,7 +324,7 @@ impl<'a> DisplayListFlattener<'a> {
                 .prim_interner
                 .intern(&prim_key, || {
                     PrimitiveSceneData {
-                        clip_rect: LayoutRect::max_rect(),
+                        normalized_clip_rect: LayoutRect::max_rect(),
                         prim_size: LayoutSize::zero(),
                         is_backface_visible: true,
                     }
@@ -1035,19 +1035,23 @@ impl<'a> DisplayListFlattener<'a> {
         spatial_node_index: SpatialNodeIndex,
         prim_key_kind: PrimitiveKeyKind,
     ) -> PrimitiveInstance {
+        let normalized_clip_rect = info.clip_rect
+            .translate(&LayoutVector2D::new(-info.rect.origin.x, -info.rect.origin.y))
+            .into();
+
         // Build a primitive key.
         let prim_key = PrimitiveKey::new(
             info.is_backface_visible,
             info.rect.size,
-            info.clip_rect,
+            normalized_clip_rect,
             prim_key_kind,
         );
 
         let prim_data_handle = self.resources
             .prim_interner
             .intern(&prim_key, || {
                 PrimitiveSceneData {
-                    clip_rect: info.clip_rect,
+                    normalized_clip_rect,
                     prim_size: info.rect.size,
                     is_backface_visible: info.is_backface_visible,
                 }
@@ -1237,7 +1241,7 @@ impl<'a> DisplayListFlattener<'a> {
             .prim_interner
             .intern(&prim_key, || {
                 PrimitiveSceneData {
-                    clip_rect: LayoutRect::max_rect(),
+                    normalized_clip_rect: LayoutRect::max_rect(),
                     prim_size: LayoutSize::zero(),
                     is_backface_visible,
                 }
@@ -1803,7 +1807,7 @@ impl<'a> DisplayListFlattener<'a> {
                             .prim_interner
                             .intern(&shadow_prim_key, || {
                                 PrimitiveSceneData {
-                                    clip_rect: LayoutRect::max_rect(),
+                                    normalized_clip_rect: LayoutRect::max_rect(),
                                     prim_size: LayoutSize::zero(),
                                     is_backface_visible: true,
                                 }

webrender/src/picture.rs

@@ -5,7 +5,7 @@
 use api::{DeviceRect, FilterOp, MixBlendMode, PipelineId, PremultipliedColorF, PictureRect, PicturePoint};
 use api::{DeviceIntRect, DevicePoint, LayoutRect, PictureToRasterTransform, LayoutPixel, PropertyBinding, PropertyBindingId};
 use api::{DevicePixelScale, RasterRect, RasterSpace, PictureSize, DeviceIntPoint, ColorF, ImageKey, DirtyRect};
-use api::{PicturePixel, RasterPixel, WorldPixel, WorldRect, ImageFormat, ImageDescriptor};
+use api::{PicturePixel, RasterPixel, WorldPixel, WorldRect, ImageFormat, ImageDescriptor, LayoutVector2D};
 use box_shadow::{BLUR_SAMPLE_SCALE};
 use clip::{ClipNodeCollector, ClipStore, ClipChainId, ClipChainNode, ClipUid};
 use clip_scroll_tree::{ROOT_SPATIAL_NODE_INDEX, ClipScrollTree, SpatialNodeIndex};
@@ -619,11 +619,15 @@ impl TileCache {
             prim_data.prim_size,
         );
 
+        let clip_rect = prim_data
+            .normalized_clip_rect
+            .translate(&LayoutVector2D::new(prim_instance.prim_origin.x, prim_instance.prim_origin.y));
+
         // Map the primitive local rect into the picture space.
         // TODO(gw): We should maybe store this in the primitive template
         //           during interning so that we never have to calculate
         //           it during frame building.
-        let culling_rect = match prim_rect.intersection(&prim_data.clip_rect) {
+        let culling_rect = match prim_rect.intersection(&clip_rect) {
             Some(rect) => rect,
             None => return,
         };
@@ -1321,7 +1325,10 @@ impl PrimitiveList {
                     prim_instance.prim_origin,
                     prim_data.prim_size,
                 );
-                let culling_rect = prim_data.clip_rect
+                let clip_rect = prim_data
+                    .normalized_clip_rect
+                    .translate(&LayoutVector2D::new(prim_instance.prim_origin.x, prim_instance.prim_origin.y));
+                let culling_rect = clip_rect
                     .intersection(&prim_rect)
                     .unwrap_or(LayoutRect::zero());
 

webrender/src/prim_store.rs

@@ -334,7 +334,7 @@ impl GpuCacheAddress {
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct PrimitiveSceneData {
     pub prim_size: LayoutSize,
-    pub clip_rect: LayoutRect,
+    pub normalized_clip_rect: LayoutRect,
     pub is_backface_visible: bool,
 }
 
@@ -630,21 +630,21 @@ impl From<LayoutPoint> for PointKey {
 pub struct PrimitiveKey {
     pub is_backface_visible: bool,
     pub prim_size: SizeKey,
-    pub clip_rect: RectangleKey,
+    pub normalized_clip_rect: RectangleKey,
     pub kind: PrimitiveKeyKind,
 }
 
 impl PrimitiveKey {
     pub fn new(
         is_backface_visible: bool,
         prim_size: LayoutSize,
-        clip_rect: LayoutRect,
+        normalized_clip_rect: LayoutRect,
         kind: PrimitiveKeyKind,
     ) -> Self {
         PrimitiveKey {
             is_backface_visible,
             prim_size: prim_size.into(),
-            clip_rect: clip_rect.into(),
+            normalized_clip_rect: normalized_clip_rect.into(),
             kind,
         }
     }
@@ -986,7 +986,7 @@ impl PrimitiveKeyKind {
 pub struct PrimitiveTemplate {
     pub is_backface_visible: bool,
     pub prim_size: LayoutSize,
-    pub clip_rect: LayoutRect,
+    pub normalized_clip_rect: LayoutRect,
     pub kind: PrimitiveTemplateKind,
     pub opacity: PrimitiveOpacity,
     /// The GPU cache handle for a primitive template. Since this structure
@@ -999,13 +999,13 @@ pub struct PrimitiveTemplate {
 impl From<PrimitiveKey> for PrimitiveTemplate {
     fn from(item: PrimitiveKey) -> Self {
         let prim_size = item.prim_size.into();
-        let clip_rect = item.clip_rect.into();
+        let normalized_clip_rect = item.normalized_clip_rect.into();
         let kind = item.kind.into_template(prim_size);
 
         PrimitiveTemplate {
             is_backface_visible: item.is_backface_visible,
             prim_size,
-            clip_rect,
+            normalized_clip_rect,
             kind,
             gpu_cache_handle: GpuCacheHandle::new(),
             opacity: PrimitiveOpacity::translucent(),
@@ -2939,7 +2939,11 @@ impl PrimitiveStore {
                     prim_instance.prim_origin,
                     prim_data.prim_size,
                 );
-                (prim_rect, prim_data.clip_rect)
+                let clip_rect = prim_data
+                    .normalized_clip_rect
+                    .translate(&LayoutVector2D::new(prim_instance.prim_origin.x, prim_instance.prim_origin.y));
+
+                (prim_rect, clip_rect)
             }
         };