Fix copied shared quad state in CCDelegatedRendererLayerImpl::appendRenderPassQuads

Previous code was modifying the shared state multiple times.
Also, the clip rect was not correctly transformed by the layer's transform, so fixed that.

BUG=None


Review URL: https://chromiumcodereview.appspot.com/11049020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@159974 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 86 insertions, 11 deletions

diff --git a/cc/CCDelegatedRendererLayerImpl.cpp b/cc/CCDelegatedRendererLayerImpl.cpp
index 4c6c753..02d5698 100644
--- a/cc/CCDelegatedRendererLayerImpl.cpp
+++ b/cc/CCDelegatedRendererLayerImpl.cpp
@@ -8,6 +8,7 @@
 
 #include "CCAppendQuadsData.h"
 #include "CCQuadSink.h"
+#include "CCMathUtil.h"
 #include "CCRenderPassDrawQuad.h"
 #include "CCRenderPassSink.h"
 
@@ -146,20 +147,20 @@ void CCDelegatedRendererLayerImpl::appendRenderPassQuads(CCQuadSink& quadSink, C
         if (quad->sharedQuadState() != currentSharedQuadState) {
             currentSharedQuadState = quad->sharedQuadState();
             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy());
+            bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
+            if (!targetIsFromDelegatedRendererLayer) {
+              // Should be the root render pass.
+              ASSERT(delegatedRenderPass == m_renderPassesInDrawOrder.last());
+              // This layer must be drawing to a renderTarget other than itself.
+              ASSERT(renderTarget() != this);
+
+              copiedSharedQuadState->clippedRectInTarget = CCMathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clippedRectInTarget);
+              copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
+              copiedSharedQuadState->opacity *= drawOpacity();
+            }
         }
         ASSERT(copiedSharedQuadState);
 
-        bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
-        if (!targetIsFromDelegatedRendererLayer) {
-            // Should be the root render pass.
-            ASSERT(delegatedRenderPass == m_renderPassesInDrawOrder.last());
-            // This layer must be drawing to a renderTarget other than itself.
-            ASSERT(renderTarget() != this);
-
-            copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
-            copiedSharedQuadState->opacity *= drawOpacity();
-        }
-
         scoped_ptr<CCDrawQuad> copyQuad;
         if (quad->material() != CCDrawQuad::RenderPass)
             copyQuad = quad->copy(copiedSharedQuadState);
diff --git a/cc/CCDelegatedRendererLayerImplTest.cpp b/cc/CCDelegatedRendererLayerImplTest.cpp
index 2fdf5f0..2796974 100644
--- a/cc/CCDelegatedRendererLayerImplTest.cpp
+++ b/cc/CCDelegatedRendererLayerImplTest.cpp
@@ -377,4 +377,78 @@ TEST_F(CCDelegatedRendererLayerImplTestOwnSurface, QuadsFromRootRenderPassAreNot
     EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasses[1]->quadList()[0]->quadTransform());
 }
 
+class CCDelegatedRendererLayerImplTestSharedData : public CCDelegatedRendererLayerImplTest {
+public:
+    CCDelegatedRendererLayerImplTestSharedData()
+        : CCDelegatedRendererLayerImplTest()
+    {
+        OwnPtr<CCLayerImpl> rootLayer = CCLayerImpl::create(1);
+        OwnPtr<CCDelegatedRendererLayerImpl> delegatedRendererLayer = CCDelegatedRendererLayerImpl::create(2);
+
+        m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
+        rootLayer->setBounds(IntSize(100, 100));
+
+        delegatedRendererLayer->setPosition(IntPoint(20, 20));
+        delegatedRendererLayer->setBounds(IntSize(20, 20));
+        delegatedRendererLayer->setContentBounds(IntSize(20, 20));
+        delegatedRendererLayer->setDrawsContent(true);
+        WebTransformationMatrix transform;
+        transform.translate(10, 10);
+        delegatedRendererLayer->setTransform(transform);
+
+        ScopedPtrVector<CCRenderPass> delegatedRenderPasses;
+        IntRect passRect(0, 0, 50, 50);
+        CCTestRenderPass* pass = addRenderPass(delegatedRenderPasses, CCRenderPass::Id(9, 6), passRect, WebTransformationMatrix());
+        MockCCQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
+        CCAppendQuadsData data(pass->id());
+        CCSharedQuadState* sharedState = quadSink.useSharedQuadState(CCSharedQuadState::create(WebTransformationMatrix(), passRect, passRect, 1, false));
+        quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(0, 0, 10, 10), 1u).PassAs<CCDrawQuad>(), data);
+        quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(0, 10, 10, 10), 2u).PassAs<CCDrawQuad>(), data);
+        quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(10, 0, 10, 10), 3u).PassAs<CCDrawQuad>(), data);
+        quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(10, 10, 10, 10), 4u).PassAs<CCDrawQuad>(), data);
+        delegatedRendererLayer->setRenderPasses(delegatedRenderPasses);
+
+        // The RenderPasses should be taken by the layer.
+        EXPECT_EQ(0u, delegatedRenderPasses.size());
+
+        m_rootLayerPtr = rootLayer.get();
+        m_delegatedRendererLayerPtr = delegatedRendererLayer.get();
+
+        rootLayer->addChild(delegatedRendererLayer.release());
+
+        m_hostImpl->setRootLayer(rootLayer.release());
+    }
+
+protected:
+    CCLayerImpl* m_rootLayerPtr;
+    CCDelegatedRendererLayerImpl* m_delegatedRendererLayerPtr;
+};
+
+TEST_F(CCDelegatedRendererLayerImplTestSharedData, SharedData)
+{
+    CCLayerTreeHostImpl::FrameData frame;
+    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+    m_hostImpl->drawLayers(frame);
+    m_hostImpl->didDrawAllLayers(frame);
+
+    ASSERT_EQ(1u, frame.renderPasses.size());
+    EXPECT_EQ(1, frame.renderPasses[0]->id().layerId);
+    EXPECT_EQ(0, frame.renderPasses[0]->id().index);
+
+    const CCQuadList& quadList = frame.renderPasses[0]->quadList();
+    ASSERT_EQ(4u, quadList.size());
+
+    // All quads should share the same state.
+    const CCSharedQuadState* sharedState = quadList[0]->sharedQuadState();
+    EXPECT_EQ(sharedState, quadList[1]->sharedQuadState());
+    EXPECT_EQ(sharedState, quadList[2]->sharedQuadState());
+    EXPECT_EQ(sharedState, quadList[3]->sharedQuadState());
+
+    // The state should be transformed only once.
+    EXPECT_RECT_EQ(IntRect(30, 30, 50, 50), sharedState->clippedRectInTarget);
+    WebTransformationMatrix expected;
+    expected.translate(30, 30);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->quadTransform);
+}
+
 } // namespace