cc: Test to verify the order of the transforms when mapping to the delegated renderer layer

cc/delegated_renderer_layer_impl_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/quad_sink.h"
@@ skipping 363 matching lines @@
     DelegatedRendererLayerImplTestSharedData()
         : DelegatedRendererLayerImplTest()
     {
         scoped_ptr<LayerImpl> rootLayer = LayerImpl::create(m_hostImpl->activeTree(), 1);
         scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer = DelegatedRendererLayerImpl::create(m_hostImpl->activeTree(), 2);
 
         m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
         rootLayer->setBounds(gfx::Size(100, 100));
 
         delegatedRendererLayer->setPosition(gfx::Point(20, 20));
-        delegatedRendererLayer->setBounds(gfx::Size(20, 20));
-        delegatedRendererLayer->setContentBounds(gfx::Size(20, 20));
+        delegatedRendererLayer->setBounds(gfx::Size(30, 30)); 
+        delegatedRendererLayer->setContentBounds(gfx::Size(30, 30));
         delegatedRendererLayer->setDrawsContent(true);
         gfx::Transform transform;
-        transform.Translate(10, 10);
+        transform.Scale(2.0, 2.0);
+        transform.Translate(8.0, 8.0);
         delegatedRendererLayer->setTransform(transform);
 
         ScopedPtrVector<RenderPass> delegatedRenderPasses;
         gfx::Rect passRect(0, 0, 50, 50);
+        gfx::Transform passTransform;
+        passTransform.Scale(1.5, 1.5);
+        passTransform.Translate(7.0, 7.0);
+
         TestRenderPass* pass = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 6), passRect, gfx::Transform());
         MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
         AppendQuadsData data(pass->id);
         SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
-        sharedState->SetAll(gfx::Transform(), passRect, passRect, passRect, false, 1);
+        sharedState->SetAll(passTransform, passRect, passRect, passRect, false, 1);
         scoped_ptr<SolidColorDrawQuad> colorQuad;
 
         colorQuad = SolidColorDrawQuad::Create();
         colorQuad->SetNew(sharedState, gfx::Rect(0, 0, 10, 10), 1u);
         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 
         colorQuad = SolidColorDrawQuad::Create();
         colorQuad->SetNew(sharedState, gfx::Rect(0, 10, 10, 10), 2u);
         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 
@@ skipping 35 matching lines @@
     const QuadList& quadList = frame.renderPasses[0]->quad_list;
     ASSERT_EQ(4u, quadList.size());
 
     // All quads should share the same state.
     const SharedQuadState* sharedState = quadList[0]->shared_quad_state;
     EXPECT_EQ(sharedState, quadList[1]->shared_quad_state);
     EXPECT_EQ(sharedState, quadList[2]->shared_quad_state);
     EXPECT_EQ(sharedState, quadList[3]->shared_quad_state);
 
     // The state should be transformed only once.
-    EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clipped_rect_in_target);
-    EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clip_rect);
+    // The x/y values are: position (20) + transform (8 * 2) = 36
+    // 36 - (width / 2) = 36 - 30 / 2 = 21
+    EXPECT_RECT_EQ(gfx::Rect(21, 21, 100, 100), sharedState->clipped_rect_in_target);
+    EXPECT_RECT_EQ(gfx::Rect(21, 21, 100, 100), sharedState->clip_rect);
     gfx::Transform expected;
-    expected.Translate(30, 30);
+    // The position (20) - the width / scale (30 / 2) = 20 - 15 = 5
+    expected.Translate(5.0, 5.0);
+    expected.Scale(2.0, 2.0);
+    expected.Translate(8.0, 8.0);
+    expected.Scale(1.5, 1.5);
+    expected.Translate(7.0, 7.0);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->content_to_target_transform);
 
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 }  // namespace
 }  // namespace cc