- Revision
- 114858
- Author
- shawnsi...@chromium.org
- Date
- 2012-04-22 13:22:24 -0700 (Sun, 22 Apr 2012)
Log Message
[chromium] Damage Tracker needs to use CCMathUtil transforms
https://bugs.webkit.org/show_bug.cgi?id=84070
Reviewed by Adrienne Walker.
Source/WebCore:
Unit test added to CCDamageTracker.cpp.
This patch makes CCDamageTracker use CCMathUtil transforms, so
that perspective w < 0 problem is correctly handled.
* platform/graphics/chromium/cc/CCDamageTracker.cpp:
(WebCore::CCDamageTracker::extendDamageForLayer):
(WebCore::CCDamageTracker::extendDamageForRenderSurface):
Source/WebKit/chromium:
* tests/CCDamageTrackerTest.cpp:
(WebKitTests::TEST_F):
(WebKitTests):
Modified Paths
Diff
Modified: trunk/Source/WebCore/ChangeLog (114857 => 114858)
--- trunk/Source/WebCore/ChangeLog 2012-04-22 16:43:27 UTC (rev 114857)
+++ trunk/Source/WebCore/ChangeLog 2012-04-22 20:22:24 UTC (rev 114858)
@@ -1,3 +1,19 @@
+2012-04-22 Shawn Singh <shawnsi...@chromium.org>
+
+ [chromium] Damage Tracker needs to use CCMathUtil transforms
+ https://bugs.webkit.org/show_bug.cgi?id=84070
+
+ Reviewed by Adrienne Walker.
+
+ Unit test added to CCDamageTracker.cpp.
+
+ This patch makes CCDamageTracker use CCMathUtil transforms, so
+ that perspective w < 0 problem is correctly handled.
+
+ * platform/graphics/chromium/cc/CCDamageTracker.cpp:
+ (WebCore::CCDamageTracker::extendDamageForLayer):
+ (WebCore::CCDamageTracker::extendDamageForRenderSurface):
+
2012-04-20 Jon Lee <jon...@apple.com>
Add Notification constructor
Modified: trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp (114857 => 114858)
--- trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp 2012-04-22 16:43:27 UTC (rev 114857)
+++ trunk/Source/WebCore/platform/graphics/chromium/cc/CCDamageTracker.cpp 2012-04-22 20:22:24 UTC (rev 114858)
@@ -37,6 +37,7 @@
#include "FilterOperations.h"
#include "cc/CCLayerImpl.h"
#include "cc/CCLayerTreeHostCommon.h"
+#include "cc/CCMathUtil.h"
#include "cc/CCRenderSurface.h"
namespace WebCore {
@@ -228,7 +229,7 @@
bool layerIsNew = false;
FloatRect oldLayerRect = removeRectFromCurrentFrame(layer->id(), layerIsNew);
- FloatRect layerRectInTargetSpace = originTransform.mapRect(FloatRect(FloatPoint::zero(), layer->bounds()));
+ FloatRect layerRectInTargetSpace = CCMathUtil::mapClippedRect(originTransform, FloatRect(FloatPoint::zero(), layer->bounds()));
saveRectForNextFrame(layer->id(), layerRectInTargetSpace);
if (layerIsNew || layer->layerPropertyChanged()) {
@@ -241,7 +242,7 @@
} else if (!layer->updateRect().isEmpty()) {
// If the layer properties havent changed, then the the target surface is only
// affected by the layer's update area, which could be empty.
- FloatRect updateRectInTargetSpace = originTransform.mapRect(layer->updateRect());
+ FloatRect updateRectInTargetSpace = CCMathUtil::mapClippedRect(originTransform, layer->updateRect());
targetDamageRect.uniteIfNonZero(updateRectInTargetSpace);
}
}
@@ -283,12 +284,12 @@
// If there was damage, transform it to target space, and possibly contribute its reflection if needed.
if (!damageRectInLocalSpace.isEmpty()) {
const TransformationMatrix& originTransform = renderSurface->originTransform();
- FloatRect damageRectInTargetSpace = originTransform.mapRect(damageRectInLocalSpace);
+ FloatRect damageRectInTargetSpace = CCMathUtil::mapClippedRect(originTransform, damageRectInLocalSpace);
targetDamageRect.uniteIfNonZero(damageRectInTargetSpace);
if (layer->replicaLayer()) {
const TransformationMatrix& replicaOriginTransform = renderSurface->replicaOriginTransform();
- targetDamageRect.uniteIfNonZero(replicaOriginTransform.mapRect(damageRectInLocalSpace));
+ targetDamageRect.uniteIfNonZero(CCMathUtil::mapClippedRect(replicaOriginTransform, damageRectInLocalSpace));
}
}
@@ -301,7 +302,7 @@
// Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
const TransformationMatrix& replicaOriginTransform = renderSurface->replicaOriginTransform();
- FloatRect replicaMaskLayerRect = replicaOriginTransform.mapRect(FloatRect(FloatPoint::zero(), FloatSize(replicaMaskLayer->bounds().width(), replicaMaskLayer->bounds().height())));
+ FloatRect replicaMaskLayerRect = CCMathUtil::mapClippedRect(replicaOriginTransform, FloatRect(FloatPoint::zero(), FloatSize(replicaMaskLayer->bounds().width(), replicaMaskLayer->bounds().height())));
saveRectForNextFrame(replicaMaskLayer->id(), replicaMaskLayerRect);
// In the current implementation, a change in the replica mask damages the entire replica region.
Modified: trunk/Source/WebKit/chromium/ChangeLog (114857 => 114858)
--- trunk/Source/WebKit/chromium/ChangeLog 2012-04-22 16:43:27 UTC (rev 114857)
+++ trunk/Source/WebKit/chromium/ChangeLog 2012-04-22 20:22:24 UTC (rev 114858)
@@ -1,3 +1,14 @@
+2012-04-22 Shawn Singh <shawnsi...@chromium.org>
+
+ [chromium] Damage Tracker needs to use CCMathUtil transforms
+ https://bugs.webkit.org/show_bug.cgi?id=84070
+
+ Reviewed by Adrienne Walker.
+
+ * tests/CCDamageTrackerTest.cpp:
+ (WebKitTests::TEST_F):
+ (WebKitTests):
+
2012-04-21 Ryosuke Niwa <rn...@webkit.org>
Chromium roll attempt from r133173 to r133348.
Modified: trunk/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp (114857 => 114858)
--- trunk/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp 2012-04-22 16:43:27 UTC (rev 114857)
+++ trunk/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp 2012-04-22 20:22:24 UTC (rev 114858)
@@ -30,6 +30,7 @@
#include "cc/CCLayerImpl.h"
#include "cc/CCLayerSorter.h"
#include "cc/CCLayerTreeHostCommon.h"
+#include "cc/CCMathUtil.h"
#include "cc/CCSingleThreadProxy.h"
#include <gtest/gtest.h>
@@ -315,6 +316,49 @@
EXPECT_FLOAT_RECT_EQ(expectedRect, rootDamageRect);
}
+TEST_F(CCDamageTrackerTest, verifyDamageForPerspectiveClippedLayer)
+{
+ // If a layer has a perspective transform that causes w < 0, then not clipping the
+ // layer can cause an invalid damage rect. This test checks that the w < 0 case is
+ // tracked properly.
+ //
+ // The transform is constructed so that if w < 0 clipping is not performed, the
+ // incorrect rect will be very small, specifically: position (-3.153448, -2.750628) and size 8.548689 x 5.661383.
+ // Instead, the correctly transformed rect should actually be very huge (i.e. in theory, infinite)
+
+ OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
+ CCLayerImpl* child = root->children()[0].get();
+
+ TransformationMatrix transform;
+ transform.applyPerspective(1);
+ transform.translate3d(-150, -50, 0);
+ transform.rotate3d(0, 45, 0);
+ transform.translate3d(-50, -50, 0);
+
+ // Set up the child
+ child->setPosition(FloatPoint(0, 0));
+ child->setBounds(IntSize(100, 100));
+ child->setTransform(transform);
+ emulateDrawingOneFrame(root.get());
+
+ // Sanity check that the child layer's bounds would actually get clipped by w < 0,
+ // otherwise this test is not actually testing the intended scenario.
+ FloatQuad testQuad(FloatRect(FloatPoint::zero(), FloatSize(100, 100)));
+ bool clipped = false;
+ CCMathUtil::mapQuad(transform, testQuad, clipped);
+ EXPECT_TRUE(clipped);
+
+ // Damage the child without moving it.
+ child->setOpacity(0.5);
+ emulateDrawingOneFrame(root.get());
+
+ // The expected damage should cover the entire root surface (500x500), but we don't
+ // care whether the damage rect was clamped or is larger than the surface for this test.
+ FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
+ EXPECT_GE(rootDamageRect.width(), 500);
+ EXPECT_GE(rootDamageRect.height(), 500);
+}
+
TEST_F(CCDamageTrackerTest, verifyDamageForBlurredSurface)
{
OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
