cc/layers/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/layers/delegated_renderer_layer_impl.h"
   6
   7 #include "cc/base/scoped_ptr_vector.h"
   8 #include "cc/layers/solid_color_layer_impl.h"
   9 #include "cc/quads/render_pass_draw_quad.h"
  10 #include "cc/quads/solid_color_draw_quad.h"
  11 #include "cc/test/fake_delegated_renderer_layer_impl.h"
  12 #include "cc/test/fake_layer_tree_host_impl.h"
  13 #include "cc/test/fake_layer_tree_host_impl_client.h"
  14 #include "cc/test/fake_output_surface.h"
  15 #include "cc/test/fake_proxy.h"
  16 #include "cc/test/fake_rendering_stats_instrumentation.h"
  17 #include "cc/test/geometry_test_utils.h"
  18 #include "cc/test/layer_test_common.h"
  19 #include "cc/test/render_pass_test_common.h"
  20 #include "cc/test/render_pass_test_utils.h"
  21 #include "cc/test/test_shared_bitmap_manager.h"
  22 #include "cc/test/test_web_graphics_context_3d.h"
  23 #include "cc/trees/layer_tree_host_impl.h"
  24 #include "cc/trees/layer_tree_impl.h"
  25 #include "cc/trees/single_thread_proxy.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "ui/gfx/frame_time.h"
  28 #include "ui/gfx/transform.h"
  29
  30 namespace cc {
  31 namespace {
  32
  33 class DelegatedRendererLayerImplTest : public testing::Test {
  34  public:
  35   DelegatedRendererLayerImplTest()
  36       : proxy_(),
  37         always_impl_thread_and_main_thread_blocked_(&proxy_) {
  38     LayerTreeSettings settings;
  39     settings.minimum_occlusion_tracking_size = gfx::Size();
  40
  41     host_impl_.reset(
  42         new FakeLayerTreeHostImpl(settings, &proxy_, &shared_bitmap_manager_));
  43     host_impl_->InitializeRenderer(
  44         FakeOutputSurface::Create3d().PassAs<OutputSurface>());
  45     host_impl_->SetViewportSize(gfx::Size(10, 10));
  46   }
  47
  48  protected:
  49   FakeProxy proxy_;
  50   DebugScopedSetImplThreadAndMainThreadBlocked
  51       always_impl_thread_and_main_thread_blocked_;
  52   TestSharedBitmapManager shared_bitmap_manager_;
  53   scoped_ptr<LayerTreeHostImpl> host_impl_;
  54 };
  55
  56 class DelegatedRendererLayerImplTestSimple
  57     : public DelegatedRendererLayerImplTest {
  58  public:
  59   DelegatedRendererLayerImplTestSimple()
  60       : DelegatedRendererLayerImplTest() {
  61     scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
  62         host_impl_->active_tree(), 1).PassAs<LayerImpl>();
  63     scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
  64         host_impl_->active_tree(), 2).PassAs<LayerImpl>();
  65     scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
  66         host_impl_->active_tree(), 3).PassAs<LayerImpl>();
  67     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
  68         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
  69
  70     host_impl_->SetViewportSize(gfx::Size(100, 100));
  71     root_layer->SetBounds(gfx::Size(100, 100));
  72
  73     layer_before->SetPosition(gfx::Point(20, 20));
  74     layer_before->SetBounds(gfx::Size(14, 14));
  75     layer_before->SetContentBounds(gfx::Size(14, 14));
  76     layer_before->SetDrawsContent(true);
  77     layer_before->SetForceRenderSurface(true);
  78
  79     layer_after->SetPosition(gfx::Point(5, 5));
  80     layer_after->SetBounds(gfx::Size(15, 15));
  81     layer_after->SetContentBounds(gfx::Size(15, 15));
  82     layer_after->SetDrawsContent(true);
  83     layer_after->SetForceRenderSurface(true);
  84
  85     delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
  86     delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
  87     delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
  88     delegated_renderer_layer->SetDrawsContent(true);
  89     gfx::Transform transform;
  90     transform.Translate(1.0, 1.0);
  91     delegated_renderer_layer->SetTransform(transform);
  92
  93     RenderPassList delegated_render_passes;
  94     TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
  95                                           RenderPass::Id(9, 6),
  96                                           gfx::Rect(6, 6, 6, 6),
  97                                           gfx::Transform(1, 0, 0, 1, 5, 6));
  98     AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
  99     TestRenderPass* pass2 = AddRenderPass(&delegated_render_passes,
 100                                           RenderPass::Id(9, 7),
 101                                           gfx::Rect(7, 7, 7, 7),
 102                                           gfx::Transform(1, 0, 0, 1, 7, 8));
 103     AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
 104     AddRenderPassQuad(pass2, pass1);
 105     TestRenderPass* pass3 = AddRenderPass(&delegated_render_passes,
 106                                           RenderPass::Id(9, 8),
 107                                           gfx::Rect(0, 0, 8, 8),
 108                                           gfx::Transform(1, 0, 0, 1, 9, 10));
 109     AddRenderPassQuad(pass3, pass2);
 110     delegated_renderer_layer->SetFrameDataForRenderPasses(
 111         1.f, &delegated_render_passes);
 112
 113     // The RenderPasses should be taken by the layer.
 114     EXPECT_EQ(0u, delegated_render_passes.size());
 115
 116     root_layer_ = root_layer.get();
 117     layer_before_ = layer_before.get();
 118     layer_after_ = layer_after.get();
 119     delegated_renderer_layer_ = delegated_renderer_layer.get();
 120
 121     // Force the delegated RenderPasses to come before the RenderPass from
 122     // layer_after.
 123     layer_after->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
 124     root_layer->AddChild(layer_after.Pass());
 125
 126     // Get the RenderPass generated by layer_before to come before the delegated
 127     // RenderPasses.
 128     root_layer->AddChild(layer_before.Pass());
 129     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 130   }
 131
 132  protected:
 133   LayerImpl* root_layer_;
 134   LayerImpl* layer_before_;
 135   LayerImpl* layer_after_;
 136   DelegatedRendererLayerImpl* delegated_renderer_layer_;
 137 };
 138
 139 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
 140   LayerTreeHostImpl::FrameData frame;
 141   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 142
 143   // Each non-DelegatedRendererLayer added one RenderPass. The
 144   // DelegatedRendererLayer added two contributing passes.
 145   ASSERT_EQ(5u, frame.render_passes.size());
 146
 147   // The DelegatedRendererLayer should have added its contributing RenderPasses
 148   // to the frame.
 149   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
 150   EXPECT_EQ(1, frame.render_passes[1]->id.index);
 151   EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
 152   EXPECT_EQ(2, frame.render_passes[2]->id.index);
 153   // And all other RenderPasses should be non-delegated.
 154   EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
 155   EXPECT_EQ(0, frame.render_passes[0]->id.index);
 156   EXPECT_NE(4, frame.render_passes[3]->id.layer_id);
 157   EXPECT_EQ(0, frame.render_passes[3]->id.index);
 158   EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
 159   EXPECT_EQ(0, frame.render_passes[4]->id.index);
 160
 161   // The DelegatedRendererLayer should have added its RenderPasses to the frame
 162   // in order.
 163   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
 164             frame.render_passes[1]->output_rect.ToString());
 165   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
 166             frame.render_passes[2]->output_rect.ToString());
 167
 168   host_impl_->DrawLayers(&frame);
 169   host_impl_->DidDrawAllLayers(frame);
 170 }
 171
 172 TEST_F(DelegatedRendererLayerImplTestSimple,
 173        AddsQuadsToContributingRenderPasses) {
 174   LayerTreeHostImpl::FrameData frame;
 175   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 176
 177   // Each non-DelegatedRendererLayer added one RenderPass. The
 178   // DelegatedRendererLayer added two contributing passes.
 179   ASSERT_EQ(5u, frame.render_passes.size());
 180
 181   // The DelegatedRendererLayer should have added its contributing RenderPasses
 182   // to the frame.
 183   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
 184   EXPECT_EQ(1, frame.render_passes[1]->id.index);
 185   EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
 186   EXPECT_EQ(2, frame.render_passes[2]->id.index);
 187
 188   // The DelegatedRendererLayer should have added copies of its quads to
 189   // contributing RenderPasses.
 190   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 191   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
 192             frame.render_passes[1]->quad_list[0]->rect.ToString());
 193
 194   // Verify it added the right quads.
 195   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
 196   EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
 197             frame.render_passes[2]->quad_list[0]->rect.ToString());
 198   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
 199             frame.render_passes[2]->quad_list[1]->rect.ToString());
 200   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 201   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
 202             frame.render_passes[1]->quad_list[0]->rect.ToString());
 203
 204   host_impl_->DrawLayers(&frame);
 205   host_impl_->DidDrawAllLayers(frame);
 206 }
 207
 208 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
 209   LayerTreeHostImpl::FrameData frame;
 210   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 211
 212   // Each non-DelegatedRendererLayer added one RenderPass. The
 213   // DelegatedRendererLayer added two contributing passes.
 214   ASSERT_EQ(5u, frame.render_passes.size());
 215
 216   // The layer's target is the RenderPass from layer_after_.
 217   EXPECT_EQ(RenderPass::Id(3, 0), frame.render_passes[3]->id);
 218
 219   // The DelegatedRendererLayer should have added copies of quads in its root
 220   // RenderPass to its target RenderPass. The layer_after_ also adds one quad.
 221   ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
 222
 223   // Verify it added the right quads.
 224   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
 225             frame.render_passes[3]->quad_list[0]->rect.ToString());
 226
 227   // Its target layer should have a quad as well.
 228   EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
 229             frame.render_passes[3]->quad_list[1]->rect.ToString());
 230
 231   host_impl_->DrawLayers(&frame);
 232   host_impl_->DidDrawAllLayers(frame);
 233 }
 234
 235 TEST_F(DelegatedRendererLayerImplTestSimple,
 236        QuadsFromRootRenderPassAreModifiedForTheTarget) {
 237   LayerTreeHostImpl::FrameData frame;
 238   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 239
 240   // Each non-DelegatedRendererLayer added one RenderPass. The
 241   // DelegatedRendererLayer added two contributing passes.
 242   ASSERT_EQ(5u, frame.render_passes.size());
 243
 244   // The DelegatedRendererLayer is at position 3,3 compared to its target, and
 245   // has a translation transform of 1,1. So its root RenderPass' quads should
 246   // all be transformed by that combined amount.
 247   gfx::Transform transform;
 248   transform.Translate(4.0, 4.0);
 249   EXPECT_TRANSFORMATION_MATRIX_EQ(
 250       transform, frame.render_passes[3]->quad_list[0]->quadTransform());
 251
 252   // Quads from non-root RenderPasses should not be shifted though.
 253   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
 254   EXPECT_TRANSFORMATION_MATRIX_EQ(
 255       gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
 256   EXPECT_TRANSFORMATION_MATRIX_EQ(
 257       gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
 258   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 259   EXPECT_TRANSFORMATION_MATRIX_EQ(
 260       gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
 261
 262   host_impl_->DrawLayers(&frame);
 263   host_impl_->DidDrawAllLayers(frame);
 264 }
 265
 266 TEST_F(DelegatedRendererLayerImplTestSimple, RenderPassTransformIsModified) {
 267   LayerTreeHostImpl::FrameData frame;
 268   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 269
 270   // The delegated layer has a surface between it and the root.
 271   EXPECT_TRUE(delegated_renderer_layer_->render_target()->parent());
 272
 273   // Each non-DelegatedRendererLayer added one RenderPass. The
 274   // DelegatedRendererLayer added two contributing passes.
 275   ASSERT_EQ(5u, frame.render_passes.size());
 276
 277   // The DelegatedRendererLayer is at position 9,9 compared to the root, so all
 278   // render pass' transforms to the root should be shifted by this amount.
 279   gfx::Transform transform;
 280   transform.Translate(9.0, 9.0);
 281
 282   // The first contributing surface has a translation of 5, 6.
 283   gfx::Transform five_six(1, 0, 0, 1, 5, 6);
 284
 285   // The second contributing surface has a translation of 7, 8.
 286   gfx::Transform seven_eight(1, 0, 0, 1, 7, 8);
 287
 288   EXPECT_TRANSFORMATION_MATRIX_EQ(
 289       transform * five_six, frame.render_passes[1]->transform_to_root_target);
 290   EXPECT_TRANSFORMATION_MATRIX_EQ(
 291       transform * seven_eight,
 292       frame.render_passes[2]->transform_to_root_target);
 293
 294   host_impl_->DrawLayers(&frame);
 295   host_impl_->DidDrawAllLayers(frame);
 296 }
 297
 298 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
 299   LayerTreeHostImpl::FrameData frame;
 300   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 301
 302   // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
 303   // has no need to be a RenderSurface for the quads it carries.
 304   EXPECT_FALSE(delegated_renderer_layer_->render_surface());
 305
 306   host_impl_->DrawLayers(&frame);
 307   host_impl_->DidDrawAllLayers(frame);
 308 }
 309
 310 TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
 311   delegated_renderer_layer_->SetOpacity(0.5f);
 312
 313   LayerTreeHostImpl::FrameData frame;
 314   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 315
 316   // This test case has quads from multiple layers in the delegated renderer, so
 317   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
 318   // render surface.
 319   EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 320
 321   host_impl_->DrawLayers(&frame);
 322   host_impl_->DidDrawAllLayers(frame);
 323 }
 324
 325 TEST_F(DelegatedRendererLayerImplTestSimple,
 326        DoesOwnARenderSurfaceForTransform) {
 327   gfx::Transform rotation;
 328   rotation.RotateAboutZAxis(30.0);
 329   delegated_renderer_layer_->SetTransform(rotation);
 330
 331   LayerTreeHostImpl::FrameData frame;
 332   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 333
 334   // This test case has quads from multiple layers in the delegated renderer, so
 335   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
 336   // render surface.
 337   EXPECT_TRUE(delegated_renderer_layer_->render_surface());
 338
 339   host_impl_->DrawLayers(&frame);
 340   host_impl_->DidDrawAllLayers(frame);
 341 }
 342
 343 class DelegatedRendererLayerImplTestOwnSurface
 344     : public DelegatedRendererLayerImplTestSimple {
 345  public:
 346   DelegatedRendererLayerImplTestOwnSurface()
 347       : DelegatedRendererLayerImplTestSimple() {
 348     delegated_renderer_layer_->SetForceRenderSurface(true);
 349   }
 350 };
 351
 352 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
 353   LayerTreeHostImpl::FrameData frame;
 354   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 355
 356   // Each non-DelegatedRendererLayer added one RenderPass. The
 357   // DelegatedRendererLayer added two contributing passes and its owned surface
 358   // added one pass.
 359   ASSERT_EQ(6u, frame.render_passes.size());
 360
 361   // The DelegatedRendererLayer should have added its contributing RenderPasses
 362   // to the frame.
 363   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
 364   EXPECT_EQ(1, frame.render_passes[1]->id.index);
 365   EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
 366   EXPECT_EQ(2, frame.render_passes[2]->id.index);
 367   // The DelegatedRendererLayer should have added a RenderPass for its surface
 368   // to the frame.
 369   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
 370   EXPECT_EQ(0, frame.render_passes[3]->id.index);
 371   // And all other RenderPasses should be non-delegated.
 372   EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
 373   EXPECT_EQ(0, frame.render_passes[0]->id.index);
 374   EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
 375   EXPECT_EQ(0, frame.render_passes[4]->id.index);
 376   EXPECT_NE(4, frame.render_passes[5]->id.layer_id);
 377   EXPECT_EQ(0, frame.render_passes[5]->id.index);
 378
 379   // The DelegatedRendererLayer should have added its RenderPasses to the frame
 380   // in order.
 381   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
 382             frame.render_passes[1]->output_rect.ToString());
 383   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
 384             frame.render_passes[2]->output_rect.ToString());
 385
 386   host_impl_->DrawLayers(&frame);
 387   host_impl_->DidDrawAllLayers(frame);
 388 }
 389
 390 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
 391        AddsQuadsToContributingRenderPasses) {
 392   LayerTreeHostImpl::FrameData frame;
 393   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 394
 395   // Each non-DelegatedRendererLayer added one RenderPass. The
 396   // DelegatedRendererLayer added two contributing passes and its owned surface
 397   // added one pass.
 398   ASSERT_EQ(6u, frame.render_passes.size());
 399
 400   // The DelegatedRendererLayer should have added its contributing RenderPasses
 401   // to the frame.
 402   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
 403   EXPECT_EQ(1, frame.render_passes[1]->id.index);
 404   EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
 405   EXPECT_EQ(2, frame.render_passes[2]->id.index);
 406
 407   // The DelegatedRendererLayer should have added copies of its quads to
 408   // contributing RenderPasses.
 409   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 410   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
 411             frame.render_passes[1]->quad_list[0]->rect.ToString());
 412
 413   // Verify it added the right quads.
 414   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
 415   EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
 416             frame.render_passes[2]->quad_list[0]->rect.ToString());
 417   EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
 418             frame.render_passes[2]->quad_list[1]->rect.ToString());
 419   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 420   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
 421             frame.render_passes[1]->quad_list[0]->rect.ToString());
 422
 423   host_impl_->DrawLayers(&frame);
 424   host_impl_->DidDrawAllLayers(frame);
 425 }
 426
 427 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
 428   LayerTreeHostImpl::FrameData frame;
 429   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 430
 431   // Each non-DelegatedRendererLayer added one RenderPass. The
 432   // DelegatedRendererLayer added two contributing passes and its owned surface
 433   // added one pass.
 434   ASSERT_EQ(6u, frame.render_passes.size());
 435
 436   // The layer's target is the RenderPass owned by itself.
 437   EXPECT_EQ(RenderPass::Id(4, 0), frame.render_passes[3]->id);
 438
 439   // The DelegatedRendererLayer should have added copies of quads in its root
 440   // RenderPass to its target RenderPass.
 441   // The layer_after also adds one quad.
 442   ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
 443
 444   // Verify it added the right quads.
 445   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
 446             frame.render_passes[3]->quad_list[0]->rect.ToString());
 447
 448   host_impl_->DrawLayers(&frame);
 449   host_impl_->DidDrawAllLayers(frame);
 450 }
 451
 452 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
 453        QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
 454   LayerTreeHostImpl::FrameData frame;
 455   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 456
 457   // Each non-DelegatedRendererLayer added one RenderPass. The
 458   // DelegatedRendererLayer added two contributing passes and its owned surface
 459   // added one pass.
 460   ASSERT_EQ(6u, frame.render_passes.size());
 461
 462   // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
 463   // RenderPass' quads do not need to be translated at all.
 464   EXPECT_TRANSFORMATION_MATRIX_EQ(
 465       gfx::Transform(), frame.render_passes[3]->quad_list[0]->quadTransform());
 466
 467   // Quads from non-root RenderPasses should not be shifted either.
 468   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
 469   EXPECT_TRANSFORMATION_MATRIX_EQ(
 470       gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
 471   EXPECT_TRANSFORMATION_MATRIX_EQ(
 472       gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
 473   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
 474   EXPECT_TRANSFORMATION_MATRIX_EQ(
 475       gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
 476
 477   host_impl_->DrawLayers(&frame);
 478   host_impl_->DidDrawAllLayers(frame);
 479 }
 480
 481 class DelegatedRendererLayerImplTestTransform
 482     : public DelegatedRendererLayerImplTest {
 483  public:
 484   DelegatedRendererLayerImplTestTransform()
 485       : root_delegated_render_pass_is_clipped_(false),
 486         delegated_device_scale_factor_(2.f) {}
 487
 488   void SetUpTest() {
 489     host_impl_->SetDeviceScaleFactor(2.f);
 490
 491     scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
 492         host_impl_->active_tree(), 1);
 493     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
 494         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
 495
 496     host_impl_->SetViewportSize(gfx::Size(200, 200));
 497     root_layer->SetBounds(gfx::Size(100, 100));
 498
 499     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
 500     delegated_renderer_layer->SetBounds(gfx::Size(75, 75));
 501     delegated_renderer_layer->SetContentBounds(gfx::Size(75, 75));
 502     delegated_renderer_layer->SetDrawsContent(true);
 503     gfx::Transform transform;
 504     transform.Scale(2.0, 2.0);
 505     transform.Translate(8.0, 8.0);
 506     delegated_renderer_layer->SetTransform(transform);
 507
 508     RenderPassList delegated_render_passes;
 509
 510     gfx::Size child_pass_content_bounds(7, 7);
 511     gfx::Rect child_pass_rect(20, 20, 7, 7);
 512     gfx::Transform child_pass_transform;
 513     child_pass_transform.Scale(0.8f, 0.8f);
 514     child_pass_transform.Translate(9.0, 9.0);
 515     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
 516     bool child_pass_clipped = false;
 517
 518     {
 519       TestRenderPass* pass = AddRenderPass(
 520           &delegated_render_passes,
 521           RenderPass::Id(10, 7),
 522           child_pass_rect,
 523           gfx::Transform());
 524       SharedQuadState* shared_quad_state =
 525           pass->CreateAndAppendSharedQuadState();
 526       shared_quad_state->SetAll(child_pass_transform,
 527                                 child_pass_content_bounds,
 528                                 child_pass_rect,
 529                                 child_pass_clip_rect,
 530                                 child_pass_clipped,
 531                                 1.f,
 532                                 SkXfermode::kSrcOver_Mode,
 533                                 0);
 534
 535       SolidColorDrawQuad* color_quad;
 536       color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 537       color_quad->SetNew(shared_quad_state,
 538                          gfx::Rect(20, 20, 3, 7),
 539                          gfx::Rect(20, 20, 3, 7),
 540                          1u,
 541                          false);
 542
 543       color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 544       color_quad->SetNew(shared_quad_state,
 545                          gfx::Rect(23, 20, 4, 7),
 546                          gfx::Rect(23, 20, 4, 7),
 547                          1u,
 548                          false);
 549     }
 550
 551     gfx::Size root_pass_content_bounds(100, 100);
 552     gfx::Rect root_pass_rect(0, 0, 100, 100);
 553     gfx::Transform root_pass_transform;
 554     root_pass_transform.Scale(1.5, 1.5);
 555     root_pass_transform.Translate(7.0, 7.0);
 556     gfx::Rect root_pass_clip_rect(10, 10, 35, 35);
 557     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 558
 559     TestRenderPass* pass = AddRenderPass(
 560         &delegated_render_passes,
 561         RenderPass::Id(9, 6),
 562         root_pass_rect,
 563         gfx::Transform());
 564     SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState();
 565     shared_quad_state->SetAll(root_pass_transform,
 566                               root_pass_content_bounds,
 567                               root_pass_rect,
 568                               root_pass_clip_rect,
 569                               root_pass_clipped,
 570                               1.f,
 571                               SkXfermode::kSrcOver_Mode,
 572                               0);
 573
 574     RenderPassDrawQuad* render_pass_quad =
 575         pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
 576     render_pass_quad->SetNew(
 577         shared_quad_state,
 578         gfx::Rect(5, 5, 7, 7),  // quad_rect
 579         gfx::Rect(5, 5, 7, 7),  // visible_rect
 580         RenderPass::Id(10, 7),  // render_pass_id
 581         false,                  // is_replica
 582         0,                      // mask_resource_id
 583         child_pass_rect,        // contents_changed_since_last_frame
 584         gfx::RectF(),           // mask_uv_rect
 585         FilterOperations(),     // filters
 586         FilterOperations());    // background_filters
 587
 588     SolidColorDrawQuad* color_quad;
 589     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 590     color_quad->SetNew(shared_quad_state,
 591                        gfx::Rect(0, 0, 10, 10),
 592                        gfx::Rect(0, 0, 10, 10),
 593                        1u,
 594                        false);
 595
 596     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 597     color_quad->SetNew(shared_quad_state,
 598                        gfx::Rect(0, 10, 10, 10),
 599                        gfx::Rect(0, 10, 10, 10),
 600                        2u,
 601                        false);
 602
 603     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 604     color_quad->SetNew(shared_quad_state,
 605                        gfx::Rect(10, 0, 10, 10),
 606                        gfx::Rect(10, 0, 10, 10),
 607                        3u,
 608                        false);
 609
 610     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 611     color_quad->SetNew(shared_quad_state,
 612                        gfx::Rect(10, 10, 10, 10),
 613                        gfx::Rect(10, 10, 10, 10),
 614                        4u,
 615                        false);
 616
 617     delegated_renderer_layer->SetFrameDataForRenderPasses(
 618         delegated_device_scale_factor_, &delegated_render_passes);
 619
 620     // The RenderPasses should be taken by the layer.
 621     EXPECT_EQ(0u, delegated_render_passes.size());
 622
 623     root_layer_ = root_layer.get();
 624     delegated_renderer_layer_ = delegated_renderer_layer.get();
 625
 626     root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
 627     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 628   }
 629
 630   void VerifyRenderPasses(
 631       const LayerTreeHostImpl::FrameData& frame,
 632       size_t num_render_passes,
 633       const SharedQuadState** root_delegated_shared_quad_state,
 634       const SharedQuadState** contrib_delegated_shared_quad_state) {
 635     ASSERT_EQ(num_render_passes, frame.render_passes.size());
 636     // The contributing render pass in the DelegatedRendererLayer.
 637     EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
 638     EXPECT_EQ(1, frame.render_passes[0]->id.index);
 639     // The root render pass.
 640     EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
 641     EXPECT_EQ(0, frame.render_passes.back()->id.index);
 642
 643     const QuadList& contrib_delegated_quad_list =
 644         frame.render_passes[0]->quad_list;
 645     ASSERT_EQ(2u, contrib_delegated_quad_list.size());
 646
 647     const QuadList& root_delegated_quad_list =
 648         frame.render_passes[1]->quad_list;
 649     ASSERT_EQ(5u, root_delegated_quad_list.size());
 650
 651     // All quads in a render pass should share the same state.
 652     *contrib_delegated_shared_quad_state =
 653         contrib_delegated_quad_list[0]->shared_quad_state;
 654     EXPECT_EQ(*contrib_delegated_shared_quad_state,
 655               contrib_delegated_quad_list[1]->shared_quad_state);
 656
 657     *root_delegated_shared_quad_state =
 658         root_delegated_quad_list[0]->shared_quad_state;
 659     EXPECT_EQ(*root_delegated_shared_quad_state,
 660               root_delegated_quad_list[1]->shared_quad_state);
 661     EXPECT_EQ(*root_delegated_shared_quad_state,
 662               root_delegated_quad_list[2]->shared_quad_state);
 663     EXPECT_EQ(*root_delegated_shared_quad_state,
 664               root_delegated_quad_list[3]->shared_quad_state);
 665     EXPECT_EQ(*root_delegated_shared_quad_state,
 666               root_delegated_quad_list[4]->shared_quad_state);
 667
 668     EXPECT_NE(*contrib_delegated_shared_quad_state,
 669               *root_delegated_shared_quad_state);
 670   }
 671
 672  protected:
 673   LayerImpl* root_layer_;
 674   DelegatedRendererLayerImpl* delegated_renderer_layer_;
 675   bool root_delegated_render_pass_is_clipped_;
 676   float delegated_device_scale_factor_;
 677 };
 678
 679 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
 680   root_delegated_render_pass_is_clipped_ = false;
 681   SetUpTest();
 682
 683   LayerTreeHostImpl::FrameData frame;
 684   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 685
 686   const SharedQuadState* root_delegated_shared_quad_state = NULL;
 687   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
 688   VerifyRenderPasses(
 689       frame,
 690       2,
 691       &root_delegated_shared_quad_state,
 692       &contrib_delegated_shared_quad_state);
 693
 694   // When the quads don't have a clip of their own, the clip rect is set to
 695   // the drawable_content_rect of the delegated renderer layer.
 696   EXPECT_EQ(delegated_renderer_layer_->drawable_content_rect().ToString(),
 697             root_delegated_shared_quad_state->clip_rect.ToString());
 698
 699   // Even though the quads in the root pass have no clip of their own, they
 700   // inherit the clip rect from the delegated renderer layer if it does not
 701   // own a surface.
 702   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 703
 704   gfx::Transform expected;
 705   // Device scale factor.
 706   expected.Scale(2.0, 2.0);
 707   // This is the transform from the layer's space to its target.
 708   expected.Translate(20, 20);
 709   expected.Scale(2.0, 2.0);
 710   expected.Translate(8.0, 8.0);
 711   // This is the transform within the source frame.
 712   // Inverse device scale factor to go from physical space to layer space.
 713   expected.Scale(0.5, 0.5);
 714   expected.Scale(1.5, 1.5);
 715   expected.Translate(7.0, 7.0);
 716   EXPECT_TRANSFORMATION_MATRIX_EQ(
 717       expected, root_delegated_shared_quad_state->content_to_target_transform);
 718
 719   // The contributing render pass should not be transformed from its input.
 720   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
 721             contrib_delegated_shared_quad_state->clip_rect.ToString());
 722   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
 723   expected.MakeIdentity();
 724   expected.Scale(0.8f, 0.8f);
 725   expected.Translate(9.0, 9.0);
 726   EXPECT_TRANSFORMATION_MATRIX_EQ(
 727       expected,
 728       contrib_delegated_shared_quad_state->content_to_target_transform);
 729
 730   host_impl_->DrawLayers(&frame);
 731   host_impl_->DidDrawAllLayers(frame);
 732 }
 733
 734 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
 735   root_delegated_render_pass_is_clipped_ = true;
 736   SetUpTest();
 737
 738   LayerTreeHostImpl::FrameData frame;
 739   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 740
 741   const SharedQuadState* root_delegated_shared_quad_state = NULL;
 742   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
 743   VerifyRenderPasses(
 744       frame,
 745       2,
 746       &root_delegated_shared_quad_state,
 747       &contrib_delegated_shared_quad_state);
 748
 749   // Since the quads have a clip_rect it should be modified by delegated
 750   // renderer layer's draw_transform.
 751   // The position of the resulting clip_rect is:
 752   // (clip rect position (10) * inverse dsf (1/2) + translate (8)) *
 753   //     layer scale (2) + layer position (20) = 46
 754   // The device scale is 2, so everything gets doubled, giving 92.
 755   //
 756   // The size is 35x35 scaled by the device scale.
 757   EXPECT_EQ(gfx::Rect(92, 92, 70, 70).ToString(),
 758             root_delegated_shared_quad_state->clip_rect.ToString());
 759
 760   // The quads had a clip and it should be preserved.
 761   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 762
 763   gfx::Transform expected;
 764   // Device scale factor.
 765   expected.Scale(2.0, 2.0);
 766   // This is the transform from the layer's space to its target.
 767   expected.Translate(20, 20);
 768   expected.Scale(2.0, 2.0);
 769   expected.Translate(8.0, 8.0);
 770   // This is the transform within the source frame.
 771   // Inverse device scale factor to go from physical space to layer space.
 772   expected.Scale(0.5, 0.5);
 773   expected.Scale(1.5, 1.5);
 774   expected.Translate(7.0, 7.0);
 775   EXPECT_TRANSFORMATION_MATRIX_EQ(
 776       expected, root_delegated_shared_quad_state->content_to_target_transform);
 777
 778   // The contributing render pass should not be transformed from its input.
 779   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
 780             contrib_delegated_shared_quad_state->clip_rect.ToString());
 781   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
 782   expected.MakeIdentity();
 783   expected.Scale(0.8f, 0.8f);
 784   expected.Translate(9.0, 9.0);
 785   EXPECT_TRANSFORMATION_MATRIX_EQ(
 786       expected,
 787       contrib_delegated_shared_quad_state->content_to_target_transform);
 788
 789   host_impl_->DrawLayers(&frame);
 790   host_impl_->DidDrawAllLayers(frame);
 791 }
 792
 793 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
 794   root_delegated_render_pass_is_clipped_ = false;
 795   SetUpTest();
 796
 797   delegated_renderer_layer_->SetForceRenderSurface(true);
 798
 799   LayerTreeHostImpl::FrameData frame;
 800   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 801
 802   const SharedQuadState* root_delegated_shared_quad_state = NULL;
 803   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
 804   VerifyRenderPasses(
 805       frame,
 806       3,
 807       &root_delegated_shared_quad_state,
 808       &contrib_delegated_shared_quad_state);
 809
 810   // When the layer owns a surface, then its position and translation are not
 811   // a part of its draw transform.
 812   EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
 813             root_delegated_shared_quad_state->clip_rect.ToString());
 814
 815   // Since the layer owns a surface it doesn't need to clip its quads, so
 816   // unclipped quads remain unclipped.
 817   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 818
 819   gfx::Transform expected;
 820   // This is the transform within the source frame.
 821   expected.Scale(1.5, 1.5);
 822   expected.Translate(7.0, 7.0);
 823   EXPECT_TRANSFORMATION_MATRIX_EQ(
 824       expected, root_delegated_shared_quad_state->content_to_target_transform);
 825
 826   // The contributing render pass should not be transformed from its input.
 827   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
 828             contrib_delegated_shared_quad_state->clip_rect.ToString());
 829   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
 830   expected.MakeIdentity();
 831   expected.Scale(0.8f, 0.8f);
 832   expected.Translate(9.0, 9.0);
 833   EXPECT_TRANSFORMATION_MATRIX_EQ(
 834       expected,
 835       contrib_delegated_shared_quad_state->content_to_target_transform);
 836
 837   host_impl_->DrawLayers(&frame);
 838   host_impl_->DidDrawAllLayers(frame);
 839 }
 840
 841 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
 842   root_delegated_render_pass_is_clipped_ = true;
 843   SetUpTest();
 844
 845   delegated_renderer_layer_->SetForceRenderSurface(true);
 846
 847   LayerTreeHostImpl::FrameData frame;
 848   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 849
 850   const SharedQuadState* root_delegated_shared_quad_state = NULL;
 851   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
 852   VerifyRenderPasses(
 853       frame,
 854       3,
 855       &root_delegated_shared_quad_state,
 856       &contrib_delegated_shared_quad_state);
 857
 858   // When the layer owns a surface, then its position and translation are not
 859   // a part of its draw transform. The clip_rect should be preserved.
 860   EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
 861             root_delegated_shared_quad_state->clip_rect.ToString());
 862
 863   // The quads had a clip and it should be preserved.
 864   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 865
 866   gfx::Transform expected;
 867   // This is the transform within the source frame.
 868   expected.Scale(1.5, 1.5);
 869   expected.Translate(7.0, 7.0);
 870   EXPECT_TRANSFORMATION_MATRIX_EQ(
 871       expected, root_delegated_shared_quad_state->content_to_target_transform);
 872
 873   // The contributing render pass should not be transformed from its input.
 874   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
 875             contrib_delegated_shared_quad_state->clip_rect.ToString());
 876   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
 877   expected.MakeIdentity();
 878   expected.Scale(0.8f, 0.8f);
 879   expected.Translate(9.0, 9.0);
 880   EXPECT_TRANSFORMATION_MATRIX_EQ(
 881       expected,
 882       contrib_delegated_shared_quad_state->content_to_target_transform);
 883
 884   host_impl_->DrawLayers(&frame);
 885   host_impl_->DidDrawAllLayers(frame);
 886 }
 887
 888 TEST_F(DelegatedRendererLayerImplTestTransform, MismatchedDeviceScaleFactor) {
 889   root_delegated_render_pass_is_clipped_ = true;
 890   delegated_device_scale_factor_ = 1.3f;
 891
 892   SetUpTest();
 893
 894   LayerTreeHostImpl::FrameData frame;
 895   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 896
 897   const SharedQuadState* root_delegated_shared_quad_state = NULL;
 898   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
 899   VerifyRenderPasses(frame,
 900                      2,
 901                      &root_delegated_shared_quad_state,
 902                      &contrib_delegated_shared_quad_state);
 903
 904   // The parent tree's device scale factor is 2.0, but the child has submitted a
 905   // frame with a device scale factor of 1.3.  Absent any better option, the
 906   // only thing we can do is scale from 1.3 -> 2.0.
 907
 908   gfx::Transform expected;
 909   // Device scale factor (from parent).
 910   expected.Scale(2.0, 2.0);
 911   // This is the transform from the layer's space to its target.
 912   expected.Translate(20, 20);
 913   expected.Scale(2.0, 2.0);
 914   expected.Translate(8.0, 8.0);
 915   // This is the transform within the source frame.
 916   // Inverse device scale factor (from child).
 917   expected.Scale(1.0f / 1.3f, 1.0f / 1.3f);
 918   expected.Scale(1.5, 1.5);
 919   expected.Translate(7.0, 7.0);
 920   EXPECT_TRANSFORMATION_MATRIX_EQ(
 921       expected, root_delegated_shared_quad_state->content_to_target_transform);
 922
 923   host_impl_->DrawLayers(&frame);
 924   host_impl_->DidDrawAllLayers(frame);
 925 }
 926
 927 class DelegatedRendererLayerImplTestClip
 928     : public DelegatedRendererLayerImplTest {
 929  public:
 930   void SetUpTest() {
 931     scoped_ptr<LayerImpl> root_layer =
 932         LayerImpl::Create(host_impl_->active_tree(), 1);
 933     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
 934         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
 935     scoped_ptr<LayerImpl> clip_layer =
 936         LayerImpl::Create(host_impl_->active_tree(), 3);
 937     scoped_ptr<LayerImpl> origin_layer =
 938         LayerImpl::Create(host_impl_->active_tree(), 4);
 939
 940     host_impl_->SetViewportSize(gfx::Size(100, 100));
 941     root_layer->SetBounds(gfx::Size(100, 100));
 942
 943     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
 944     delegated_renderer_layer->SetBounds(gfx::Size(50, 50));
 945     delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50));
 946     delegated_renderer_layer->SetDrawsContent(true);
 947
 948     RenderPassList delegated_render_passes;
 949
 950     gfx::Size child_pass_content_bounds(7, 7);
 951     gfx::Rect child_pass_rect(20, 20, 7, 7);
 952     gfx::Transform child_pass_transform;
 953     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
 954     bool child_pass_clipped = false;
 955
 956     {
 957       TestRenderPass* pass = AddRenderPass(
 958           &delegated_render_passes,
 959           RenderPass::Id(10, 7),
 960           child_pass_rect,
 961           gfx::Transform());
 962       SharedQuadState* shared_quad_state =
 963           pass->CreateAndAppendSharedQuadState();
 964       shared_quad_state->SetAll(child_pass_transform,
 965                                 child_pass_content_bounds,
 966                                 child_pass_rect,
 967                                 child_pass_clip_rect,
 968                                 child_pass_clipped,
 969                                 1.f,
 970                                 SkXfermode::kSrcOver_Mode,
 971                                 0);
 972
 973       SolidColorDrawQuad* color_quad;
 974       color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 975       color_quad->SetNew(shared_quad_state,
 976                          gfx::Rect(20, 20, 3, 7),
 977                          gfx::Rect(20, 20, 3, 7),
 978                          1u,
 979                          false);
 980
 981       color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 982       color_quad->SetNew(shared_quad_state,
 983                          gfx::Rect(23, 20, 4, 7),
 984                          gfx::Rect(23, 20, 4, 7),
 985                          1u,
 986                          false);
 987     }
 988
 989     gfx::Size root_pass_content_bounds(50, 50);
 990     gfx::Rect root_pass_rect(0, 0, 50, 50);
 991     gfx::Transform root_pass_transform;
 992     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
 993     bool root_pass_clipped = root_delegated_render_pass_is_clipped_;
 994
 995     TestRenderPass* pass = AddRenderPass(
 996         &delegated_render_passes,
 997         RenderPass::Id(9, 6),
 998         root_pass_rect,
 999         gfx::Transform());
1000     SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState();
1001     shared_quad_state->SetAll(root_pass_transform,
1002                               root_pass_content_bounds,
1003                               root_pass_rect,
1004                               root_pass_clip_rect,
1005                               root_pass_clipped,
1006                               1.f,
1007                               SkXfermode::kSrcOver_Mode,
1008                               0);
1009
1010     RenderPassDrawQuad* render_pass_quad =
1011         pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1012     render_pass_quad->SetNew(
1013         shared_quad_state,
1014         gfx::Rect(5, 5, 7, 7),  // quad_rect
1015         gfx::Rect(5, 5, 7, 7),  // visible_quad_rect
1016         RenderPass::Id(10, 7),  // render_pass_id
1017         false,                  // is_replica
1018         0,                      // mask_resource_id
1019         child_pass_rect,        // contents_changed_since_last_frame
1020         gfx::RectF(),           // mask_uv_rect
1021         FilterOperations(),     // filters
1022         FilterOperations());    // background_filters
1023
1024     SolidColorDrawQuad* color_quad;
1025     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1026     color_quad->SetNew(shared_quad_state,
1027                        gfx::Rect(0, 0, 10, 10),
1028                        gfx::Rect(0, 0, 10, 10),
1029                        1u,
1030                        false);
1031
1032     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1033     color_quad->SetNew(shared_quad_state,
1034                        gfx::Rect(0, 10, 10, 10),
1035                        gfx::Rect(0, 10, 10, 10),
1036                        2u,
1037                        false);
1038
1039     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1040     color_quad->SetNew(shared_quad_state,
1041                        gfx::Rect(10, 0, 10, 10),
1042                        gfx::Rect(10, 0, 10, 10),
1043                        3u,
1044                        false);
1045
1046     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1047     color_quad->SetNew(shared_quad_state,
1048                        gfx::Rect(10, 10, 10, 10),
1049                        gfx::Rect(10, 10, 10, 10),
1050                        4u,
1051                        false);
1052
1053     delegated_renderer_layer->SetFrameDataForRenderPasses(
1054         1.f, &delegated_render_passes);
1055
1056     // The RenderPasses should be taken by the layer.
1057     EXPECT_EQ(0u, delegated_render_passes.size());
1058
1059     root_layer_ = root_layer.get();
1060     delegated_renderer_layer_ = delegated_renderer_layer.get();
1061
1062     if (clip_delegated_renderer_layer_) {
1063       gfx::Rect clip_rect(21, 27, 23, 21);
1064
1065       clip_layer->SetPosition(clip_rect.origin());
1066       clip_layer->SetBounds(clip_rect.size());
1067       clip_layer->SetContentBounds(clip_rect.size());
1068       clip_layer->SetMasksToBounds(true);
1069
1070       origin_layer->SetPosition(
1071           gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin()));
1072
1073       origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1074       clip_layer->AddChild(origin_layer.Pass());
1075       root_layer->AddChild(clip_layer.Pass());
1076     } else {
1077       root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1078     }
1079
1080     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
1081   }
1082
1083  protected:
1084   LayerImpl* root_layer_;
1085   DelegatedRendererLayerImpl* delegated_renderer_layer_;
1086   bool root_delegated_render_pass_is_clipped_;
1087   bool clip_delegated_renderer_layer_;
1088 };
1089
1090 TEST_F(DelegatedRendererLayerImplTestClip,
1091        QuadsUnclipped_LayerUnclipped_NoSurface) {
1092   root_delegated_render_pass_is_clipped_ = false;
1093   clip_delegated_renderer_layer_ = false;
1094   SetUpTest();
1095
1096   LayerTreeHostImpl::FrameData frame;
1097   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1098
1099   ASSERT_EQ(2u, frame.render_passes.size());
1100   const QuadList& contrib_delegated_quad_list =
1101       frame.render_passes[0]->quad_list;
1102   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1103   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1104   ASSERT_EQ(5u, root_delegated_quad_list.size());
1105   const SharedQuadState* root_delegated_shared_quad_state =
1106       root_delegated_quad_list[0]->shared_quad_state;
1107
1108   // When the quads don't have a clip of their own, the clip rect is set to
1109   // the drawable_content_rect of the delegated renderer layer.
1110   EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
1111             root_delegated_shared_quad_state->clip_rect.ToString());
1112   // Quads are clipped to the delegated renderer layer.
1113   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1114
1115   host_impl_->DrawLayers(&frame);
1116   host_impl_->DidDrawAllLayers(frame);
1117 }
1118
1119 TEST_F(DelegatedRendererLayerImplTestClip,
1120        QuadsClipped_LayerUnclipped_NoSurface) {
1121   root_delegated_render_pass_is_clipped_ = true;
1122   clip_delegated_renderer_layer_ = false;
1123   SetUpTest();
1124
1125   LayerTreeHostImpl::FrameData frame;
1126   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1127
1128   ASSERT_EQ(2u, frame.render_passes.size());
1129   const QuadList& contrib_delegated_quad_list =
1130       frame.render_passes[0]->quad_list;
1131   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1132   const QuadList& root_delegated_quad_list =
1133       frame.render_passes[1]->quad_list;
1134   ASSERT_EQ(5u, root_delegated_quad_list.size());
1135   const SharedQuadState* root_delegated_shared_quad_state =
1136       root_delegated_quad_list[0]->shared_quad_state;
1137
1138   // When the quads have a clip of their own, it is used.
1139   EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
1140             root_delegated_shared_quad_state->clip_rect.ToString());
1141   // Quads came with a clip rect.
1142   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1143
1144   host_impl_->DrawLayers(&frame);
1145   host_impl_->DidDrawAllLayers(frame);
1146 }
1147
1148 TEST_F(DelegatedRendererLayerImplTestClip,
1149        QuadsUnclipped_LayerClipped_NoSurface) {
1150   root_delegated_render_pass_is_clipped_ = false;
1151   clip_delegated_renderer_layer_ = true;
1152   SetUpTest();
1153
1154   LayerTreeHostImpl::FrameData frame;
1155   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1156
1157   ASSERT_EQ(2u, frame.render_passes.size());
1158   const QuadList& contrib_delegated_quad_list =
1159       frame.render_passes[0]->quad_list;
1160   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1161   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1162   ASSERT_EQ(5u, root_delegated_quad_list.size());
1163   const SharedQuadState* root_delegated_shared_quad_state =
1164       root_delegated_quad_list[0]->shared_quad_state;
1165
1166   // When the quads don't have a clip of their own, the clip rect is set to
1167   // the drawable_content_rect of the delegated renderer layer. When the layer
1168   // is clipped, that should be seen in the quads' clip_rect.
1169   EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
1170             root_delegated_shared_quad_state->clip_rect.ToString());
1171   // Quads are clipped to the delegated renderer layer.
1172   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1173
1174   host_impl_->DrawLayers(&frame);
1175   host_impl_->DidDrawAllLayers(frame);
1176 }
1177
1178 TEST_F(DelegatedRendererLayerImplTestClip,
1179        QuadsClipped_LayerClipped_NoSurface) {
1180   root_delegated_render_pass_is_clipped_ = true;
1181   clip_delegated_renderer_layer_ = true;
1182   SetUpTest();
1183
1184   LayerTreeHostImpl::FrameData frame;
1185   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1186
1187   ASSERT_EQ(2u, frame.render_passes.size());
1188   const QuadList& contrib_delegated_quad_list =
1189       frame.render_passes[0]->quad_list;
1190   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1191   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1192   ASSERT_EQ(5u, root_delegated_quad_list.size());
1193   const SharedQuadState* root_delegated_shared_quad_state =
1194       root_delegated_quad_list[0]->shared_quad_state;
1195
1196   // When the quads have a clip of their own, it is used, but it is
1197   // combined with the clip rect of the delegated renderer layer.
1198   EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(),
1199             root_delegated_shared_quad_state->clip_rect.ToString());
1200   // Quads came with a clip rect.
1201   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1202
1203   host_impl_->DrawLayers(&frame);
1204   host_impl_->DidDrawAllLayers(frame);
1205 }
1206
1207 TEST_F(DelegatedRendererLayerImplTestClip,
1208        QuadsUnclipped_LayerUnclipped_Surface) {
1209   root_delegated_render_pass_is_clipped_ = false;
1210   clip_delegated_renderer_layer_ = false;
1211   SetUpTest();
1212
1213   delegated_renderer_layer_->SetForceRenderSurface(true);
1214
1215   LayerTreeHostImpl::FrameData frame;
1216   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1217
1218   ASSERT_EQ(3u, frame.render_passes.size());
1219   const QuadList& contrib_delegated_quad_list =
1220       frame.render_passes[0]->quad_list;
1221   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1222   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1223   ASSERT_EQ(5u, root_delegated_quad_list.size());
1224   const SharedQuadState* root_delegated_shared_quad_state =
1225       root_delegated_quad_list[0]->shared_quad_state;
1226
1227   // When the layer owns a surface, the quads don't need to be clipped
1228   // further than they already specify. If they aren't clipped, then their
1229   // clip rect is ignored, and they are not set as clipped.
1230   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1231
1232   host_impl_->DrawLayers(&frame);
1233   host_impl_->DidDrawAllLayers(frame);
1234 }
1235
1236 TEST_F(DelegatedRendererLayerImplTestClip,
1237        QuadsClipped_LayerUnclipped_Surface) {
1238   root_delegated_render_pass_is_clipped_ = true;
1239   clip_delegated_renderer_layer_ = false;
1240   SetUpTest();
1241
1242   delegated_renderer_layer_->SetForceRenderSurface(true);
1243
1244   LayerTreeHostImpl::FrameData frame;
1245   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1246
1247   ASSERT_EQ(3u, frame.render_passes.size());
1248   const QuadList& contrib_delegated_quad_list =
1249       frame.render_passes[0]->quad_list;
1250   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1251   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1252   ASSERT_EQ(5u, root_delegated_quad_list.size());
1253   const SharedQuadState* root_delegated_shared_quad_state =
1254       root_delegated_quad_list[0]->shared_quad_state;
1255
1256   // When the quads have a clip of their own, it is used.
1257   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1258             root_delegated_shared_quad_state->clip_rect.ToString());
1259   // Quads came with a clip rect.
1260   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1261
1262   host_impl_->DrawLayers(&frame);
1263   host_impl_->DidDrawAllLayers(frame);
1264 }
1265
1266 TEST_F(DelegatedRendererLayerImplTestClip,
1267        QuadsUnclipped_LayerClipped_Surface) {
1268   root_delegated_render_pass_is_clipped_ = false;
1269   clip_delegated_renderer_layer_ = true;
1270   SetUpTest();
1271
1272   delegated_renderer_layer_->SetForceRenderSurface(true);
1273
1274   LayerTreeHostImpl::FrameData frame;
1275   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1276
1277   ASSERT_EQ(3u, frame.render_passes.size());
1278   const QuadList& contrib_delegated_quad_list =
1279       frame.render_passes[0]->quad_list;
1280   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1281   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1282   ASSERT_EQ(5u, root_delegated_quad_list.size());
1283   const SharedQuadState* root_delegated_shared_quad_state =
1284       root_delegated_quad_list[0]->shared_quad_state;
1285
1286   // When the layer owns a surface, the quads don't need to be clipped
1287   // further than they already specify. If they aren't clipped, then their
1288   // clip rect is ignored, and they are not set as clipped.
1289   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
1290
1291   host_impl_->DrawLayers(&frame);
1292   host_impl_->DidDrawAllLayers(frame);
1293 }
1294
1295 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
1296   root_delegated_render_pass_is_clipped_ = true;
1297   clip_delegated_renderer_layer_ = true;
1298   SetUpTest();
1299
1300   delegated_renderer_layer_->SetForceRenderSurface(true);
1301
1302   LayerTreeHostImpl::FrameData frame;
1303   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1304
1305   ASSERT_EQ(3u, frame.render_passes.size());
1306   const QuadList& contrib_delegated_quad_list =
1307       frame.render_passes[0]->quad_list;
1308   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
1309   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
1310   ASSERT_EQ(5u, root_delegated_quad_list.size());
1311   const SharedQuadState* root_delegated_shared_quad_state =
1312       root_delegated_quad_list[0]->shared_quad_state;
1313
1314   // When the quads have a clip of their own, it is used, but it is
1315   // combined with the clip rect of the delegated renderer layer. If the
1316   // layer owns a surface, then it does not have a clip rect of its own.
1317   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
1318             root_delegated_shared_quad_state->clip_rect.ToString());
1319   // Quads came with a clip rect.
1320   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
1321
1322   host_impl_->DrawLayers(&frame);
1323   host_impl_->DidDrawAllLayers(frame);
1324 }
1325
1326 TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
1327   scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
1328       host_impl_->active_tree(), 1).PassAs<LayerImpl>();
1329   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
1330       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
1331
1332   host_impl_->SetViewportSize(gfx::Size(100, 100));
1333
1334   delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
1335   delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
1336   delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
1337   delegated_renderer_layer->SetDrawsContent(true);
1338
1339   RenderPassList delegated_render_passes;
1340   TestRenderPass* pass1 = AddRenderPass(
1341       &delegated_render_passes,
1342       RenderPass::Id(9, 6),
1343       gfx::Rect(0, 0, 10, 10),
1344       gfx::Transform());
1345   AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u);
1346
1347   // This render pass isn't part of the frame.
1348   scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create());
1349   missing_pass->SetNew(RenderPass::Id(9, 7),
1350                        gfx::Rect(7, 7, 7, 7),
1351                        gfx::Rect(7, 7, 7, 7),
1352                        gfx::Transform());
1353
1354   // But a render pass quad refers to it.
1355   AddRenderPassQuad(pass1, missing_pass.get());
1356
1357   delegated_renderer_layer->SetFrameDataForRenderPasses(
1358       1.f, &delegated_render_passes);
1359
1360   // The RenderPasses should be taken by the layer.
1361   EXPECT_EQ(0u, delegated_render_passes.size());
1362
1363   root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
1364   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
1365
1366   LayerTreeHostImpl::FrameData frame;
1367   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
1368
1369   // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
1370   ASSERT_EQ(1u, frame.render_passes.size());
1371   ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
1372   EXPECT_EQ(DrawQuad::SOLID_COLOR,
1373             frame.render_passes[0]->quad_list[0]->material);
1374
1375   host_impl_->DrawLayers(&frame);
1376   host_impl_->DidDrawAllLayers(frame);
1377 }
1378
1379 TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
1380   gfx::Size layer_size(1000, 1000);
1381   gfx::Size viewport_size(1000, 1000);
1382   gfx::Rect quad_rect(200, 300, 400, 500);
1383
1384   gfx::Transform transform;
1385   transform.Translate(11.0, 0.0);
1386
1387   LayerTestCommon::LayerImplTest impl;
1388
1389   FakeDelegatedRendererLayerImpl* delegated_renderer_layer_impl =
1390       impl.AddChildToRoot<FakeDelegatedRendererLayerImpl>();
1391   delegated_renderer_layer_impl->SetBounds(layer_size);
1392   delegated_renderer_layer_impl->SetContentBounds(layer_size);
1393   delegated_renderer_layer_impl->SetDrawsContent(true);
1394
1395   RenderPassList delegated_render_passes;
1396   // pass2 is just the size of the quad. It contributes to |pass1| with a
1397   // translation of (11,0).
1398   RenderPass::Id pass2_id =
1399       delegated_renderer_layer_impl->FirstContributingRenderPassId();
1400   TestRenderPass* pass2 =
1401       AddRenderPass(&delegated_render_passes, pass2_id, quad_rect, transform);
1402   AddQuad(pass2, gfx::Rect(quad_rect.size()), SK_ColorRED);
1403   // |pass1| covers the whole layer.
1404   RenderPass::Id pass1_id = RenderPass::Id(impl.root_layer()->id(), 0);
1405   TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
1406                                         pass1_id,
1407                                         gfx::Rect(layer_size),
1408                                         gfx::Transform());
1409   AddRenderPassQuad(pass1, pass2, 0, FilterOperations(), transform);
1410   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
1411       1.f, &delegated_render_passes);
1412
1413   impl.CalcDrawProps(viewport_size);
1414
1415   // The |quad_rect| translated by the |transform|.
1416   gfx::Rect quad_screen_rect = quad_rect + gfx::Vector2d(11, 0);
1417
1418   {
1419     SCOPED_TRACE("No occlusion");
1420     gfx::Rect occluded;
1421
1422     {
1423       SCOPED_TRACE("Root render pass");
1424       impl.AppendQuadsForPassWithOcclusion(
1425           delegated_renderer_layer_impl, pass1_id, occluded);
1426       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1427                                                    quad_screen_rect);
1428       ASSERT_EQ(1u, impl.quad_list().size());
1429       EXPECT_EQ(DrawQuad::RENDER_PASS, impl.quad_list()[0]->material);
1430     }
1431     {
1432       SCOPED_TRACE("Contributing render pass");
1433       impl.AppendQuadsForPassWithOcclusion(
1434           delegated_renderer_layer_impl, pass2_id, occluded);
1435       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1436                                                    gfx::Rect(quad_rect.size()));
1437       ASSERT_EQ(1u, impl.quad_list().size());
1438       EXPECT_EQ(DrawQuad::SOLID_COLOR, impl.quad_list()[0]->material);
1439     }
1440   }
1441
1442   {
1443     SCOPED_TRACE("Full occlusion");
1444     {
1445       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
1446
1447       SCOPED_TRACE("Root render pass");
1448       impl.AppendQuadsForPassWithOcclusion(
1449           delegated_renderer_layer_impl, pass1_id, occluded);
1450       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1451                                                    gfx::Rect());
1452       EXPECT_EQ(impl.quad_list().size(), 0u);
1453     }
1454     {
1455       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
1456       // Move the occlusion to where it is in the contributing surface.
1457       occluded -= quad_rect.OffsetFromOrigin();
1458
1459       SCOPED_TRACE("Contributing render pass");
1460       impl.AppendQuadsForPassWithOcclusion(
1461           delegated_renderer_layer_impl, pass2_id, occluded);
1462       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
1463                                                    gfx::Rect());
1464       EXPECT_EQ(impl.quad_list().size(), 0u);
1465     }
1466   }
1467
1468   {
1469     SCOPED_TRACE("Partial occlusion");
1470     {
1471       gfx::Rect occluded(0, 0, 500, 1000);
1472
1473       SCOPED_TRACE("Root render pass");
1474       impl.AppendQuadsForPassWithOcclusion(
1475           delegated_renderer_layer_impl, pass1_id, occluded);
1476       size_t partially_occluded_count = 0;
1477       LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
1478           impl.quad_list(),
1479           quad_screen_rect,
1480           occluded,
1481           &partially_occluded_count);
1482       // The layer outputs one quad, which is partially occluded.
1483       EXPECT_EQ(1u, impl.quad_list().size());
1484       EXPECT_EQ(1u, partially_occluded_count);
1485     }
1486     {
1487       gfx::Rect occluded(0, 0, 500, 1000);
1488       // Move the occlusion to where it is in the contributing surface.
1489       occluded -= quad_rect.OffsetFromOrigin() + gfx::Vector2d(11, 0);
1490
1491       SCOPED_TRACE("Contributing render pass");
1492       impl.AppendQuadsForPassWithOcclusion(
1493           delegated_renderer_layer_impl, pass2_id, occluded);
1494       size_t partially_occluded_count = 0;
1495       LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
1496           impl.quad_list(),
1497           gfx::Rect(quad_rect.size()),
1498           occluded,
1499           &partially_occluded_count);
1500       // The layer outputs one quad, which is partially occluded.
1501       EXPECT_EQ(1u, impl.quad_list().size());
1502       EXPECT_EQ(1u, partially_occluded_count);
1503       // The quad in the contributing surface is at (211,300) in the root.
1504       // The occlusion extends to 500 in the x-axis, pushing the left of the
1505       // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
1506       EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
1507                 impl.quad_list()[0]->visible_rect.ToString());
1508     }
1509   }
1510 }
1511
1512 TEST_F(DelegatedRendererLayerImplTest, PushPropertiesTo) {
1513   gfx::Size layer_size(1000, 1000);
1514
1515   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer_impl =
1516       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 5);
1517   delegated_renderer_layer_impl->SetBounds(layer_size);
1518   delegated_renderer_layer_impl->SetContentBounds(layer_size);
1519   delegated_renderer_layer_impl->SetDrawsContent(true);
1520
1521   RenderPassList delegated_render_passes;
1522   // |pass1| covers the whole layer.
1523   RenderPass::Id pass1_id = RenderPass::Id(5, 0);
1524   AddRenderPass(&delegated_render_passes,
1525                 pass1_id,
1526                 gfx::Rect(layer_size),
1527                 gfx::Transform());
1528   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
1529       2.f, &delegated_render_passes);
1530   EXPECT_EQ(0.5f, delegated_renderer_layer_impl->inverse_device_scale_factor());
1531
1532   scoped_ptr<DelegatedRendererLayerImpl> other_layer =
1533       DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
1534
1535   delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
1536
1537   EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());
1538 }
1539
1540 }  // namespace
1541 }  // namespace cc