Changeset 117981 in webkit

Timestamp:

May 22, 2012 9:10:09 AM (12 years ago)

Author:

danakj@chromium.org

Message:

[chromium] Expand damage from the background-blurred layer to ensure readback is only including pixels below that layer
​https://bugs.webkit.org/show_bug.cgi?id=86884

Reviewed by Adrienne Walker.

Source/WebCore:

Consider layers in back-to-front order A, B, and C, where layer B has
a blur background filter applied, and C exactly covers A. When B does
its readback to perform its blur, it should include the pixels of A
not C. With partial swap, if B is damaged, that damaged area will read
pixels from outside of the damage rect. Those pixels should use the
contents of A, not C, so we must expand the damage to ensure we redraw
all pixels that are going to be included in the blur for the current
frame.

Also, when a layer below B has damage outside the contentBounds of B
but within its blur radius, then that damage will be blurred inside B,
so expand all damage within B's blurred contentBounds.

Unit test: CCDamageTrackerTest.verifyDamageForBackgroundBlurredChild

• platform/graphics/chromium/cc/CCDamageTracker.cpp:

(WebCore::expandRectWithFilters):
(WebCore::expandDamageRectInsideRectWithFilters):
(WebCore::CCDamageTracker::updateDamageTrackingState):
(WebCore::CCDamageTracker::extendDamageForRenderSurface):

Source/WebKit/chromium:

• tests/CCDamageTrackerTest.cpp:

(WebKitTests::TEST_F):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp (modified) (4 diffs)
• WebKit/chromium/ChangeLog (modified) (1 diff)
• WebKit/chromium/tests/CCDamageTrackerTest.cpp (modified) (4 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-05-22  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Expand damage from the background-blurred layer to ensure readback is only including pixels below that layer
+        https://bugs.webkit.org/show_bug.cgi?id=86884
+
+        Reviewed by Adrienne Walker.
+
+        Consider layers in back-to-front order A, B, and C, where layer B has
+        a blur background filter applied, and C exactly covers A. When B does
+        its readback to perform its blur, it should include the pixels of A
+        not C. With partial swap, if B is damaged, that damaged area will read
+        pixels from outside of the damage rect. Those pixels should use the
+        contents of A, not C, so we must expand the damage to ensure we redraw
+        all pixels that are going to be included in the blur for the current
+        frame.
+
+        Also, when a layer below B has damage outside the contentBounds of B
+        but within its blur radius, then that damage will be blurred inside B,
+        so expand all damage within B's blurred contentBounds.
+
+        Unit test: CCDamageTrackerTest.verifyDamageForBackgroundBlurredChild
+
+        * platform/graphics/chromium/cc/CCDamageTracker.cpp:
+        (WebCore::expandRectWithFilters):
+        (WebCore::expandDamageRectInsideRectWithFilters):
+        (WebCore::CCDamageTracker::updateDamageTrackingState):
+        (WebCore::CCDamageTracker::extendDamageForRenderSurface):
+
 2012-05-22  Mihnea Ovidenie  <mihnea@adobe.com>
 

trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp

@@ -59 +59 @@
 }
 
-static inline void expandDamageRectWithFilters(FloatRect& damageRect, const WebKit::WebFilterOperations& filters)
+static inline void expandRectWithFilters(FloatRect& rect, const WebKit::WebFilterOperations& filters)
 {
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
-    damageRect.move(-left, -top);
-    damageRect.expand(left + right, top + bottom);
-}
-
-static inline void expandDamageRectInsideRectWithFilters(FloatRect& damageRect, const FloatRect& filterRect, const WebKit::WebFilterOperations& filters)
+    rect.move(-left, -top);
+    rect.expand(left + right, top + bottom);
+}
+
+static inline void expandDamageRectInsideRectWithFilters(FloatRect& damageRect, const FloatRect& preFilterRect, const WebKit::WebFilterOperations& filters)
 {
     FloatRect expandedDamageRect = damageRect;
-    expandDamageRectWithFilters(expandedDamageRect, filters);
+    expandRectWithFilters(expandedDamageRect, filters);
+    FloatRect filterRect = preFilterRect;
+    expandRectWithFilters(filterRect, filters);
+
     expandedDamageRect.intersect(filterRect);
-
     damageRect.unite(expandedDamageRect);
 }
@@ -158 +160 @@
 
         if (filters.hasFilterThatMovesPixels())
-            expandDamageRectWithFilters(m_currentDamageRect, filters);
+            expandRectWithFilters(m_currentDamageRect, filters);
     }
 
@@ -289 +291 @@
     saveRectForNextFrame(layer->id(), surfaceRectInTargetSpace);
 
-    // If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
-    // that exists below this layer by that amount.
-    if (layer->backgroundFilters().hasFilterThatMovesPixels())
-        expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
-
     FloatRect damageRectInLocalSpace;
     if (surfaceIsNew || renderSurface->surfacePropertyChanged()) {
@@ -334 +331 @@
             targetDamageRect.uniteIfNonZero(replicaMaskLayerRect);
     }
+
+    // If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
+    // at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
+    // the contents of layers below this one in them. This means we need to redraw any pixels in the surface being used for the blur in
+    // this layer this frame.
+    if (layer->backgroundFilters().hasFilterThatMovesPixels())
+        expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
 }
 

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-05-22  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Expand damage from the background-blurred layer to ensure readback is only including pixels below that layer
+        https://bugs.webkit.org/show_bug.cgi?id=86884
+
+        Reviewed by Adrienne Walker.
+
+        * tests/CCDamageTrackerTest.cpp:
+        (WebKitTests::TEST_F):
+
 2012-05-22  David Grogan  <dgrogan@chromium.org>
 

trunk/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp

@@ -395 +395 @@
     CCLayerImpl* child2 = root->children()[1].get();
 
+    // Allow us to set damage on child1 too.
+    child1->setDrawsContent(true);
+
     WebFilterOperations filters;
     filters.append(WebFilterOperation::createBlurFilter(2));
@@ -436 +439 @@
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 
-    // CASE 3: Setting this update rect outside the contentBounds of the blurred
+    // CASE 3: Setting this update rect outside the blurred contentBounds of the blurred
     // child1 will not cause it to be expanded.
     root->setUpdateRect(FloatRect(30, 30, 2, 2));
@@ -448 +451 @@
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 
-    // CASE 4: Setting the update rect on child2, which is above child1, will
+    // CASE 4: Setting this update rect inside the blurred contentBounds but outside the
+    // original contentBounds of the blurred child1 will cause it to be expanded.
+    root->setUpdateRect(FloatRect(99, 99, 1, 1));
+
+    emulateDrawingOneFrame(root.get());
+
+    rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
+    // Damage on the root should be: position of updateRect (99, 99), expanded
+    // by the blurring on child1, but since it is 1 pixel outside the layer, the
+    // expanding should be reduced by 1.
+    expectedDamageRect = FloatRect(99, 99, 1, 1);
+    expectedDamageRect.move(-outsetLeft + 1, -outsetTop + 1);
+    expectedDamageRect.expand(outsetLeft + outsetRight - 1, outsetTop + outsetBottom - 1);
+    EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
+
+    // CASE 5: Setting the update rect on child2, which is above child1, will
     // not get blurred by child1, so it does not need to get expanded.
     child2->setUpdateRect(FloatRect(0, 0, 1, 1));
@@ -457 +475 @@
     // Damage on child2 should be: position of updateRect offset by the child's position (11, 11), and not expanded by anything.
     expectedDamageRect = FloatRect(11, 11, 1, 1);
+    EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
+
+    // CASE 6: Setting the update rect on child1 will also blur the damage, so
+    // that any pixels needed for the blur are redrawn in the current frame.
+    child1->setUpdateRect(FloatRect(0, 0, 1, 1));
+
+    emulateDrawingOneFrame(root.get());
+
+    rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
+    // Damage on child1 should be: position of updateRect offset by the child's position (100, 100), and expanded by the damage.
+    expectedDamageRect = FloatRect(100, 100, 1, 1);
+    expectedDamageRect.move(-outsetLeft, -outsetTop);
+    expectedDamageRect.expand(outsetLeft + outsetRight, outsetTop + outsetBottom);
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 }