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