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