cc/delegated_renderer_layer_impl_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/delegated_renderer_layer_impl.h"
   6
   7 #include "cc/append_quads_data.h"
   8 #include "cc/layer_tree_host_impl.h"
   9 #include "cc/quad_sink.h"
  10 #include "cc/render_pass_draw_quad.h"
  11 #include "cc/scoped_ptr_vector.h"
  12 #include "cc/single_thread_proxy.h"
  13 #include "cc/solid_color_draw_quad.h"
  14 #include "cc/solid_color_layer_impl.h"
  15 #include "cc/test/fake_layer_tree_host_impl.h"
  16 #include "cc/test/fake_layer_tree_host_impl_client.h"
  17 #include "cc/test/fake_output_surface.h"
  18 #include "cc/test/fake_proxy.h"
  19 #include "cc/test/fake_web_graphics_context_3d.h"
  20 #include "cc/test/geometry_test_utils.h"
  21 #include "cc/test/mock_quad_culler.h"
  22 #include "cc/test/render_pass_test_common.h"
  23 #include "cc/test/render_pass_test_utils.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "ui/gfx/transform.h"
  26
  27 namespace cc {
  28 namespace {
  29
  30 class DelegatedRendererLayerImplTest : public testing::Test {
  31 public:
  32     DelegatedRendererLayerImplTest()
  33         : m_proxy(scoped_ptr<Thread>(NULL))
  34         , m_alwaysImplThreadAndMainThreadBlocked(&m_proxy)
  35     {
  36         LayerTreeSettings settings;
  37         settings.minimumOcclusionTrackingSize = gfx::Size();
  38
  39         m_hostImpl = LayerTreeHostImpl::create(settings, &m_client, &m_proxy);
  40         m_hostImpl->initializeRenderer(createFakeOutputSurface());
  41         m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
  42     }
  43
  44 protected:
  45     FakeProxy m_proxy;
  46     FakeLayerTreeHostImplClient m_client;
  47     DebugScopedSetImplThreadAndMainThreadBlocked m_alwaysImplThreadAndMainThreadBlocked;
  48     scoped_ptr<LayerTreeHostImpl> m_hostImpl;
  49 };
  50
  51 class DelegatedRendererLayerImplTestSimple : public DelegatedRendererLayerImplTest {
  52 public:
  53     DelegatedRendererLayerImplTestSimple()
  54         : DelegatedRendererLayerImplTest()
  55     {
  56         scoped_ptr<LayerImpl> rootLayer = SolidColorLayerImpl::create(m_hostImpl->activeTree(), 1).PassAs<LayerImpl>();
  57         scoped_ptr<LayerImpl> layerBefore = SolidColorLayerImpl::create(m_hostImpl->activeTree(), 2).PassAs<LayerImpl>();
  58         scoped_ptr<LayerImpl> layerAfter = SolidColorLayerImpl::create(m_hostImpl->activeTree(), 3).PassAs<LayerImpl>();
  59         scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer = DelegatedRendererLayerImpl::create(m_hostImpl->activeTree(), 4);
  60
  61         m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
  62         rootLayer->setBounds(gfx::Size(100, 100));
  63
  64         layerBefore->setPosition(gfx::Point(20, 20));
  65         layerBefore->setBounds(gfx::Size(14, 14));
  66         layerBefore->setContentBounds(gfx::Size(14, 14));
  67         layerBefore->setDrawsContent(true);
  68         layerBefore->setForceRenderSurface(true);
  69
  70         layerAfter->setPosition(gfx::Point(5, 5));
  71         layerAfter->setBounds(gfx::Size(15, 15));
  72         layerAfter->setContentBounds(gfx::Size(15, 15));
  73         layerAfter->setDrawsContent(true);
  74         layerAfter->setForceRenderSurface(true);
  75
  76         delegatedRendererLayer->setPosition(gfx::Point(3, 3));
  77         delegatedRendererLayer->setBounds(gfx::Size(10, 10));
  78         delegatedRendererLayer->setContentBounds(gfx::Size(10, 10));
  79         delegatedRendererLayer->setDrawsContent(true);
  80         gfx::Transform transform;
  81         transform.Translate(1, 1);
  82         delegatedRendererLayer->setTransform(transform);
  83
  84         ScopedPtrVector<RenderPass> delegatedRenderPasses;
  85         TestRenderPass* pass1 = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 6), gfx::Rect(6, 6, 6, 6), gfx::Transform());
  86         addQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
  87         TestRenderPass* pass2 = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 7), gfx::Rect(7, 7, 7, 7), gfx::Transform());
  88         addQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
  89         addRenderPassQuad(pass2, pass1);
  90         TestRenderPass* pass3 = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 8), gfx::Rect(8, 8, 8, 8), gfx::Transform());
  91         addRenderPassQuad(pass3, pass2);
  92         delegatedRendererLayer->setRenderPasses(delegatedRenderPasses);
  93
  94         // The RenderPasses should be taken by the layer.
  95         EXPECT_EQ(0u, delegatedRenderPasses.size());
  96
  97         m_rootLayerPtr = rootLayer.get();
  98         m_layerBeforePtr = layerBefore.get();
  99         m_layerAfterPtr = layerAfter.get();
 100         m_delegatedRendererLayerPtr = delegatedRendererLayer.get();
 101
 102         // Force the delegated RenderPasses to come before the RenderPass from layerAfter.
 103         layerAfter->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 104         rootLayer->addChild(layerAfter.Pass());
 105
 106         // Get the RenderPass generated by layerBefore to come before the delegated RenderPasses.
 107         rootLayer->addChild(layerBefore.Pass());
 108
 109         m_hostImpl->setRootLayer(rootLayer.Pass());
 110     }
 111
 112 protected:
 113     LayerImpl* m_rootLayerPtr;
 114     LayerImpl* m_layerBeforePtr;
 115     LayerImpl* m_layerAfterPtr;
 116     DelegatedRendererLayerImpl* m_delegatedRendererLayerPtr;
 117 };
 118
 119 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses)
 120 {
 121     LayerTreeHostImpl::FrameData frame;
 122     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 123
 124     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes.
 125     ASSERT_EQ(5u, frame.renderPasses.size());
 126
 127     // The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
 128     EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
 129     EXPECT_EQ(1, frame.renderPasses[1]->id.index);
 130     EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
 131     EXPECT_EQ(2, frame.renderPasses[2]->id.index);
 132     // And all other RenderPasses should be non-delegated.
 133     EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
 134     EXPECT_EQ(0, frame.renderPasses[0]->id.index);
 135     EXPECT_NE(4, frame.renderPasses[3]->id.layer_id);
 136     EXPECT_EQ(0, frame.renderPasses[3]->id.index);
 137     EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
 138     EXPECT_EQ(0, frame.renderPasses[4]->id.index);
 139
 140     // The DelegatedRendererLayer should have added its RenderPasses to the frame in order.
 141     EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->output_rect);
 142     EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->output_rect);
 143
 144     m_hostImpl->drawLayers(frame);
 145     m_hostImpl->didDrawAllLayers(frame);
 146 }
 147
 148 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToContributingRenderPasses)
 149 {
 150     LayerTreeHostImpl::FrameData frame;
 151     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 152
 153     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes.
 154     ASSERT_EQ(5u, frame.renderPasses.size());
 155
 156     // The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
 157     EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
 158     EXPECT_EQ(1, frame.renderPasses[1]->id.index);
 159     EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
 160     EXPECT_EQ(2, frame.renderPasses[2]->id.index);
 161
 162     // The DelegatedRendererLayer should have added copies of its quads to contributing RenderPasses.
 163     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 164     EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
 165
 166     // Verify it added the right quads.
 167     ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
 168     EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quad_list[0]->rect);
 169     EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quad_list[1]->rect);
 170     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 171     EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
 172
 173     m_hostImpl->drawLayers(frame);
 174     m_hostImpl->didDrawAllLayers(frame);
 175 }
 176
 177 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass)
 178 {
 179     LayerTreeHostImpl::FrameData frame;
 180     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 181
 182     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes.
 183     ASSERT_EQ(5u, frame.renderPasses.size());
 184
 185     // The layer's target is the RenderPass from m_layerAfter.
 186     EXPECT_EQ(RenderPass::Id(3, 0), frame.renderPasses[3]->id);
 187
 188     // The DelegatedRendererLayer should have added copies of quads in its root RenderPass to its target RenderPass.
 189     // The m_layerAfter also adds one quad.
 190     ASSERT_EQ(2u, frame.renderPasses[3]->quad_list.size());
 191
 192     // Verify it added the right quads.
 193     EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quad_list[0]->rect);
 194
 195     // Its target layer should have a quad as well.
 196     EXPECT_RECT_EQ(gfx::Rect(0, 0, 15, 15), frame.renderPasses[3]->quad_list[1]->rect);
 197
 198     m_hostImpl->drawLayers(frame);
 199     m_hostImpl->didDrawAllLayers(frame);
 200 }
 201
 202 TEST_F(DelegatedRendererLayerImplTestSimple, QuadsFromRootRenderPassAreModifiedForTheTarget)
 203 {
 204     LayerTreeHostImpl::FrameData frame;
 205     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 206
 207     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes.
 208     ASSERT_EQ(5u, frame.renderPasses.size());
 209
 210     // The DelegatedRendererLayer is at position 3,3 compared to its target, and has a translation transform of 1,1.
 211     // So its root RenderPass' quads should all be transformed by that combined amount.
 212     gfx::Transform transform;
 213     transform.Translate(4, 4);
 214     EXPECT_TRANSFORMATION_MATRIX_EQ(transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
 215
 216     // Quads from non-root RenderPasses should not be shifted though.
 217     ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
 218     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
 219     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
 220     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 221     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
 222
 223     m_hostImpl->drawLayers(frame);
 224     m_hostImpl->didDrawAllLayers(frame);
 225 }
 226
 227 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface)
 228 {
 229     LayerTreeHostImpl::FrameData frame;
 230     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 231
 232     // If the DelegatedRendererLayer is axis aligned and has opacity 1, then
 233     // it has no need to be a renderSurface for the quads it carries.
 234     EXPECT_FALSE(m_delegatedRendererLayerPtr->renderSurface());
 235
 236     m_hostImpl->drawLayers(frame);
 237     m_hostImpl->didDrawAllLayers(frame);
 238 }
 239
 240 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurface)
 241 {
 242     m_delegatedRendererLayerPtr->setOpacity(0.5f);
 243
 244     LayerTreeHostImpl::FrameData frame;
 245     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 246
 247     // This test case has quads from multiple layers in the delegated renderer,
 248     // so if the DelegatedRendererLayer has opacity < 1, it should end up with
 249     // a render surface.
 250     EXPECT_TRUE(m_delegatedRendererLayerPtr->renderSurface());
 251
 252     m_hostImpl->drawLayers(frame);
 253     m_hostImpl->didDrawAllLayers(frame);
 254 }
 255
 256 class DelegatedRendererLayerImplTestOwnSurface : public DelegatedRendererLayerImplTestSimple {
 257 public:
 258     DelegatedRendererLayerImplTestOwnSurface()
 259         : DelegatedRendererLayerImplTestSimple()
 260     {
 261         m_delegatedRendererLayerPtr->setForceRenderSurface(true);
 262     }
 263 };
 264
 265 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses)
 266 {
 267     LayerTreeHostImpl::FrameData frame;
 268     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 269
 270     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes and its owned surface added one pass.
 271     ASSERT_EQ(6u, frame.renderPasses.size());
 272
 273     // The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
 274     EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
 275     EXPECT_EQ(1, frame.renderPasses[1]->id.index);
 276     EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
 277     EXPECT_EQ(2, frame.renderPasses[2]->id.index);
 278     // The DelegatedRendererLayer should have added a RenderPass for its surface to the frame.
 279     EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
 280     EXPECT_EQ(0, frame.renderPasses[3]->id.index);
 281     // And all other RenderPasses should be non-delegated.
 282     EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
 283     EXPECT_EQ(0, frame.renderPasses[0]->id.index);
 284     EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
 285     EXPECT_EQ(0, frame.renderPasses[4]->id.index);
 286     EXPECT_NE(4, frame.renderPasses[5]->id.layer_id);
 287     EXPECT_EQ(0, frame.renderPasses[5]->id.index);
 288
 289     // The DelegatedRendererLayer should have added its RenderPasses to the frame in order.
 290     EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[1]->output_rect);
 291     EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[2]->output_rect);
 292
 293     m_hostImpl->drawLayers(frame);
 294     m_hostImpl->didDrawAllLayers(frame);
 295 }
 296
 297 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToContributingRenderPasses)
 298 {
 299     LayerTreeHostImpl::FrameData frame;
 300     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 301
 302     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes and its owned surface added one pass.
 303     ASSERT_EQ(6u, frame.renderPasses.size());
 304
 305     // The DelegatedRendererLayer should have added its contributing RenderPasses to the frame.
 306     EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
 307     EXPECT_EQ(1, frame.renderPasses[1]->id.index);
 308     EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
 309     EXPECT_EQ(2, frame.renderPasses[2]->id.index);
 310
 311     // The DelegatedRendererLayer should have added copies of its quads to contributing RenderPasses.
 312     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 313     EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
 314
 315     // Verify it added the right quads.
 316     ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
 317     EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 7), frame.renderPasses[2]->quad_list[0]->rect);
 318     EXPECT_RECT_EQ(gfx::Rect(6, 6, 6, 6), frame.renderPasses[2]->quad_list[1]->rect);
 319     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 320     EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 6), frame.renderPasses[1]->quad_list[0]->rect);
 321
 322     m_hostImpl->drawLayers(frame);
 323     m_hostImpl->didDrawAllLayers(frame);
 324 }
 325
 326 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass)
 327 {
 328     LayerTreeHostImpl::FrameData frame;
 329     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 330
 331     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes and its owned surface added one pass.
 332     ASSERT_EQ(6u, frame.renderPasses.size());
 333
 334     // The layer's target is the RenderPass owned by itself.
 335     EXPECT_EQ(RenderPass::Id(4, 0), frame.renderPasses[3]->id);
 336
 337     // The DelegatedRendererLayer should have added copies of quads in its root RenderPass to its target RenderPass.
 338     // The m_layerAfter also adds one quad.
 339     ASSERT_EQ(1u, frame.renderPasses[3]->quad_list.size());
 340
 341     // Verify it added the right quads.
 342     EXPECT_RECT_EQ(gfx::Rect(7, 7, 7, 7), frame.renderPasses[3]->quad_list[0]->rect);
 343
 344     m_hostImpl->drawLayers(frame);
 345     m_hostImpl->didDrawAllLayers(frame);
 346 }
 347
 348 TEST_F(DelegatedRendererLayerImplTestOwnSurface, QuadsFromRootRenderPassAreNotModifiedForTheTarget)
 349 {
 350     LayerTreeHostImpl::FrameData frame;
 351     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 352
 353     // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRendererLayer added two contributing passes and its owned surface added one pass.
 354     ASSERT_EQ(6u, frame.renderPasses.size());
 355
 356     // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root RenderPass' quads do not need to be
 357     // modified at all.
 358     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[3]->quad_list[0]->quadTransform());
 359
 360     // Quads from non-root RenderPasses should not be shifted though.
 361     ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
 362     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
 363     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
 364     ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
 365     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
 366
 367     m_hostImpl->drawLayers(frame);
 368     m_hostImpl->didDrawAllLayers(frame);
 369 }
 370
 371 class DelegatedRendererLayerImplTestSharedData : public DelegatedRendererLayerImplTest {
 372 public:
 373     DelegatedRendererLayerImplTestSharedData()
 374         : DelegatedRendererLayerImplTest()
 375     {
 376         scoped_ptr<LayerImpl> rootLayer = LayerImpl::create(m_hostImpl->activeTree(), 1);
 377         scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer = DelegatedRendererLayerImpl::create(m_hostImpl->activeTree(), 2);
 378
 379         m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 380         rootLayer->setBounds(gfx::Size(100, 100));
 381
 382         delegatedRendererLayer->setPosition(gfx::Point(20, 20));
 383         delegatedRendererLayer->setBounds(gfx::Size(20, 20));
 384         delegatedRendererLayer->setContentBounds(gfx::Size(20, 20));
 385         delegatedRendererLayer->setDrawsContent(true);
 386         gfx::Transform transform;
 387         transform.Translate(10, 10);
 388         delegatedRendererLayer->setTransform(transform);
 389
 390         ScopedPtrVector<RenderPass> delegatedRenderPasses;
 391         gfx::Rect passRect(0, 0, 50, 50);
 392         TestRenderPass* pass = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 6), passRect, gfx::Transform());
 393         MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
 394         AppendQuadsData data(pass->id);
 395         SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
 396         sharedState->SetAll(gfx::Transform(), passRect, passRect, passRect, false, 1);
 397         scoped_ptr<SolidColorDrawQuad> colorQuad;
 398
 399         colorQuad = SolidColorDrawQuad::Create();
 400         colorQuad->SetNew(sharedState, gfx::Rect(0, 0, 10, 10), 1u);
 401         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 402
 403         colorQuad = SolidColorDrawQuad::Create();
 404         colorQuad->SetNew(sharedState, gfx::Rect(0, 10, 10, 10), 2u);
 405         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 406
 407         colorQuad = SolidColorDrawQuad::Create();
 408         colorQuad->SetNew(sharedState, gfx::Rect(10, 0, 10, 10), 3u);
 409         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 410
 411         colorQuad = SolidColorDrawQuad::Create();
 412         colorQuad->SetNew(sharedState, gfx::Rect(10, 10, 10, 10), 4u);
 413         quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
 414
 415         delegatedRendererLayer->setRenderPasses(delegatedRenderPasses);
 416
 417         // The RenderPasses should be taken by the layer.
 418         EXPECT_EQ(0u, delegatedRenderPasses.size());
 419
 420         m_rootLayerPtr = rootLayer.get();
 421         m_delegatedRendererLayerPtr = delegatedRendererLayer.get();
 422
 423         rootLayer->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 424
 425         m_hostImpl->setRootLayer(rootLayer.Pass());
 426     }
 427
 428 protected:
 429     LayerImpl* m_rootLayerPtr;
 430     DelegatedRendererLayerImpl* m_delegatedRendererLayerPtr;
 431 };
 432
 433 TEST_F(DelegatedRendererLayerImplTestSharedData, SharedData)
 434 {
 435     LayerTreeHostImpl::FrameData frame;
 436     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
 437
 438     ASSERT_EQ(1u, frame.renderPasses.size());
 439     EXPECT_EQ(1, frame.renderPasses[0]->id.layer_id);
 440     EXPECT_EQ(0, frame.renderPasses[0]->id.index);
 441
 442     const QuadList& quadList = frame.renderPasses[0]->quad_list;
 443     ASSERT_EQ(4u, quadList.size());
 444
 445     // All quads should share the same state.
 446     const SharedQuadState* sharedState = quadList[0]->shared_quad_state;
 447     EXPECT_EQ(sharedState, quadList[1]->shared_quad_state);
 448     EXPECT_EQ(sharedState, quadList[2]->shared_quad_state);
 449     EXPECT_EQ(sharedState, quadList[3]->shared_quad_state);
 450
 451     // The state should be transformed only once.
 452     EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clipped_rect_in_target);
 453     gfx::Transform expected;
 454     expected.Translate(30, 30);
 455     EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->content_to_target_transform);
 456
 457     m_hostImpl->drawLayers(frame);
 458     m_hostImpl->didDrawAllLayers(frame);
 459 }
 460
 461 }  // namespace
 462 }  // namespace cc