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