delegated_renderer_layer_impl_unittest.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6
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/debug/test_web_graphics_context_3d.h" 9#include "cc/layers/append_quads_data.h" 10#include "cc/layers/quad_sink.h" 11#include "cc/layers/solid_color_layer_impl.h" 12#include "cc/quads/render_pass_draw_quad.h" 13#include "cc/quads/solid_color_draw_quad.h" 14#include "cc/test/fake_delegated_renderer_layer_impl.h" 15#include "cc/test/fake_layer_tree_host_impl.h" 16#include "cc/test/fake_layer_tree_host_impl_client.h" 17#include "cc/test/fake_output_surface.h" 18#include "cc/test/fake_proxy.h" 19#include "cc/test/fake_rendering_stats_instrumentation.h" 20#include "cc/test/geometry_test_utils.h" 21#include "cc/test/mock_quad_culler.h" 22#include "cc/test/render_pass_test_common.h" 23#include "cc/test/render_pass_test_utils.h" 24#include "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/transform.h" 29 30namespace cc { 31namespace { 32 33class 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(new FakeLayerTreeHostImpl(settings, &proxy_)); 42 host_impl_->InitializeRenderer(CreateFakeOutputSurface()); 43 host_impl_->SetViewportSize(gfx::Size(10, 10)); 44 } 45 46 protected: 47 FakeProxy proxy_; 48 DebugScopedSetImplThreadAndMainThreadBlocked 49 always_impl_thread_and_main_thread_blocked_; 50 scoped_ptr<LayerTreeHostImpl> host_impl_; 51}; 52 53class DelegatedRendererLayerImplTestSimple 54 : public DelegatedRendererLayerImplTest { 55 public: 56 DelegatedRendererLayerImplTestSimple() 57 : DelegatedRendererLayerImplTest() { 58 scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create( 59 host_impl_->active_tree(), 1).PassAs<LayerImpl>(); 60 scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create( 61 host_impl_->active_tree(), 2).PassAs<LayerImpl>(); 62 scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create( 63 host_impl_->active_tree(), 3).PassAs<LayerImpl>(); 64 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 65 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4); 66 67 host_impl_->SetViewportSize(gfx::Size(100, 100)); 68 root_layer->SetBounds(gfx::Size(100, 100)); 69 70 layer_before->SetPosition(gfx::Point(20, 20)); 71 layer_before->SetBounds(gfx::Size(14, 14)); 72 layer_before->SetContentBounds(gfx::Size(14, 14)); 73 layer_before->SetDrawsContent(true); 74 layer_before->SetForceRenderSurface(true); 75 76 layer_after->SetPosition(gfx::Point(5, 5)); 77 layer_after->SetBounds(gfx::Size(15, 15)); 78 layer_after->SetContentBounds(gfx::Size(15, 15)); 79 layer_after->SetDrawsContent(true); 80 layer_after->SetForceRenderSurface(true); 81 82 delegated_renderer_layer->SetPosition(gfx::Point(3, 3)); 83 delegated_renderer_layer->SetBounds(gfx::Size(10, 10)); 84 delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10)); 85 delegated_renderer_layer->SetDrawsContent(true); 86 gfx::Transform transform; 87 transform.Translate(1.0, 1.0); 88 delegated_renderer_layer->SetTransform(transform); 89 90 ScopedPtrVector<RenderPass> delegated_render_passes; 91 TestRenderPass* pass1 = AddRenderPass( 92 &delegated_render_passes, 93 RenderPass::Id(9, 6), 94 gfx::Rect(6, 6, 6, 6), 95 gfx::Transform()); 96 AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u); 97 TestRenderPass* pass2 = AddRenderPass( 98 &delegated_render_passes, 99 RenderPass::Id(9, 7), 100 gfx::Rect(7, 7, 7, 7), 101 gfx::Transform()); 102 AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u); 103 AddRenderPassQuad(pass2, pass1); 104 TestRenderPass* pass3 = AddRenderPass( 105 &delegated_render_passes, 106 RenderPass::Id(9, 8), 107 gfx::Rect(0, 0, 8, 8), 108 gfx::Transform()); 109 AddRenderPassQuad(pass3, pass2); 110 delegated_renderer_layer->SetFrameDataForRenderPasses( 111 &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 139TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) { 140 LayerTreeHostImpl::FrameData frame; 141 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 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, base::TimeTicks::Now()); 169 host_impl_->DidDrawAllLayers(frame); 170} 171 172TEST_F(DelegatedRendererLayerImplTestSimple, 173 AddsQuadsToContributingRenderPasses) { 174 LayerTreeHostImpl::FrameData frame; 175 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 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, base::TimeTicks::Now()); 205 host_impl_->DidDrawAllLayers(frame); 206} 207 208TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) { 209 LayerTreeHostImpl::FrameData frame; 210 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 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, base::TimeTicks::Now()); 232 host_impl_->DidDrawAllLayers(frame); 233} 234 235TEST_F(DelegatedRendererLayerImplTestSimple, 236 QuadsFromRootRenderPassAreModifiedForTheTarget) { 237 LayerTreeHostImpl::FrameData frame; 238 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 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 // The DelegatedRendererLayer has a size of 10x10, but the root delegated 248 // RenderPass has a size of 8x8, so any quads should be scaled by 10/8. 249 gfx::Transform transform; 250 transform.Translate(4.0, 4.0); 251 transform.Scale(10.0 / 8.0, 10.0 / 8.0); 252 EXPECT_TRANSFORMATION_MATRIX_EQ( 253 transform, frame.render_passes[3]->quad_list[0]->quadTransform()); 254 255 // Quads from non-root RenderPasses should not be shifted though. 256 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size()); 257 EXPECT_TRANSFORMATION_MATRIX_EQ( 258 gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform()); 259 EXPECT_TRANSFORMATION_MATRIX_EQ( 260 gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform()); 261 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size()); 262 EXPECT_TRANSFORMATION_MATRIX_EQ( 263 gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform()); 264 265 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 266 host_impl_->DidDrawAllLayers(frame); 267} 268 269TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) { 270 LayerTreeHostImpl::FrameData frame; 271 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 272 273 // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it 274 // has no need to be a RenderSurface for the quads it carries. 275 EXPECT_FALSE(delegated_renderer_layer_->render_surface()); 276 277 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 278 host_impl_->DidDrawAllLayers(frame); 279} 280 281TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) { 282 delegated_renderer_layer_->SetOpacity(0.5f); 283 284 LayerTreeHostImpl::FrameData frame; 285 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 286 287 // This test case has quads from multiple layers in the delegated renderer, so 288 // if the DelegatedRendererLayer has opacity < 1, it should end up with a 289 // render surface. 290 EXPECT_TRUE(delegated_renderer_layer_->render_surface()); 291 292 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 293 host_impl_->DidDrawAllLayers(frame); 294} 295 296TEST_F(DelegatedRendererLayerImplTestSimple, 297 DoesOwnARenderSurfaceForTransform) { 298 gfx::Transform rotation; 299 rotation.RotateAboutZAxis(30.0); 300 delegated_renderer_layer_->SetTransform(rotation); 301 302 LayerTreeHostImpl::FrameData frame; 303 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 304 305 // This test case has quads from multiple layers in the delegated renderer, so 306 // if the DelegatedRendererLayer has opacity < 1, it should end up with a 307 // render surface. 308 EXPECT_TRUE(delegated_renderer_layer_->render_surface()); 309 310 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 311 host_impl_->DidDrawAllLayers(frame); 312} 313 314class DelegatedRendererLayerImplTestOwnSurface 315 : public DelegatedRendererLayerImplTestSimple { 316 public: 317 DelegatedRendererLayerImplTestOwnSurface() 318 : DelegatedRendererLayerImplTestSimple() { 319 delegated_renderer_layer_->SetForceRenderSurface(true); 320 } 321}; 322 323TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) { 324 LayerTreeHostImpl::FrameData frame; 325 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 326 327 // Each non-DelegatedRendererLayer added one RenderPass. The 328 // DelegatedRendererLayer added two contributing passes and its owned surface 329 // added one pass. 330 ASSERT_EQ(6u, frame.render_passes.size()); 331 332 // The DelegatedRendererLayer should have added its contributing RenderPasses 333 // to the frame. 334 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id); 335 EXPECT_EQ(1, frame.render_passes[1]->id.index); 336 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id); 337 EXPECT_EQ(2, frame.render_passes[2]->id.index); 338 // The DelegatedRendererLayer should have added a RenderPass for its surface 339 // to the frame. 340 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id); 341 EXPECT_EQ(0, frame.render_passes[3]->id.index); 342 // And all other RenderPasses should be non-delegated. 343 EXPECT_NE(4, frame.render_passes[0]->id.layer_id); 344 EXPECT_EQ(0, frame.render_passes[0]->id.index); 345 EXPECT_NE(4, frame.render_passes[4]->id.layer_id); 346 EXPECT_EQ(0, frame.render_passes[4]->id.index); 347 EXPECT_NE(4, frame.render_passes[5]->id.layer_id); 348 EXPECT_EQ(0, frame.render_passes[5]->id.index); 349 350 // The DelegatedRendererLayer should have added its RenderPasses to the frame 351 // in order. 352 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(), 353 frame.render_passes[1]->output_rect.ToString()); 354 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(), 355 frame.render_passes[2]->output_rect.ToString()); 356 357 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 358 host_impl_->DidDrawAllLayers(frame); 359} 360 361TEST_F(DelegatedRendererLayerImplTestOwnSurface, 362 AddsQuadsToContributingRenderPasses) { 363 LayerTreeHostImpl::FrameData frame; 364 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 365 366 // Each non-DelegatedRendererLayer added one RenderPass. The 367 // DelegatedRendererLayer added two contributing passes and its owned surface 368 // added one pass. 369 ASSERT_EQ(6u, frame.render_passes.size()); 370 371 // The DelegatedRendererLayer should have added its contributing RenderPasses 372 // to the frame. 373 EXPECT_EQ(4, frame.render_passes[1]->id.layer_id); 374 EXPECT_EQ(1, frame.render_passes[1]->id.index); 375 EXPECT_EQ(4, frame.render_passes[2]->id.layer_id); 376 EXPECT_EQ(2, frame.render_passes[2]->id.index); 377 378 // The DelegatedRendererLayer should have added copies of its quads to 379 // contributing RenderPasses. 380 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size()); 381 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(), 382 frame.render_passes[1]->quad_list[0]->rect.ToString()); 383 384 // Verify it added the right quads. 385 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size()); 386 EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(), 387 frame.render_passes[2]->quad_list[0]->rect.ToString()); 388 EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(), 389 frame.render_passes[2]->quad_list[1]->rect.ToString()); 390 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size()); 391 EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(), 392 frame.render_passes[1]->quad_list[0]->rect.ToString()); 393 394 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 395 host_impl_->DidDrawAllLayers(frame); 396} 397 398TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) { 399 LayerTreeHostImpl::FrameData frame; 400 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 401 402 // Each non-DelegatedRendererLayer added one RenderPass. The 403 // DelegatedRendererLayer added two contributing passes and its owned surface 404 // added one pass. 405 ASSERT_EQ(6u, frame.render_passes.size()); 406 407 // The layer's target is the RenderPass owned by itself. 408 EXPECT_EQ(RenderPass::Id(4, 0), frame.render_passes[3]->id); 409 410 // The DelegatedRendererLayer should have added copies of quads in its root 411 // RenderPass to its target RenderPass. 412 // The layer_after also adds one quad. 413 ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size()); 414 415 // Verify it added the right quads. 416 EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(), 417 frame.render_passes[3]->quad_list[0]->rect.ToString()); 418 419 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 420 host_impl_->DidDrawAllLayers(frame); 421} 422 423TEST_F(DelegatedRendererLayerImplTestOwnSurface, 424 QuadsFromRootRenderPassAreNotModifiedForTheTarget) { 425 LayerTreeHostImpl::FrameData frame; 426 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 427 428 // Each non-DelegatedRendererLayer added one RenderPass. The 429 // DelegatedRendererLayer added two contributing passes and its owned surface 430 // added one pass. 431 ASSERT_EQ(6u, frame.render_passes.size()); 432 433 // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root 434 // RenderPass' quads do not need to be translated at all. However, they are 435 // scaled from the frame's size (8x8) to the layer's bounds (10x10). 436 gfx::Transform transform; 437 transform.Scale(10.0 / 8.0, 10.0 / 8.0); 438 EXPECT_TRANSFORMATION_MATRIX_EQ( 439 transform, frame.render_passes[3]->quad_list[0]->quadTransform()); 440 441 // Quads from non-root RenderPasses should not be shifted either. 442 ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size()); 443 EXPECT_TRANSFORMATION_MATRIX_EQ( 444 gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform()); 445 EXPECT_TRANSFORMATION_MATRIX_EQ( 446 gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform()); 447 ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size()); 448 EXPECT_TRANSFORMATION_MATRIX_EQ( 449 gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform()); 450 451 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 452 host_impl_->DidDrawAllLayers(frame); 453} 454 455class DelegatedRendererLayerImplTestTransform 456 : public DelegatedRendererLayerImplTest { 457 public: 458 void SetUpTest() { 459 host_impl_->SetDeviceScaleFactor(2.f); 460 461 scoped_ptr<LayerImpl> root_layer = LayerImpl::Create( 462 host_impl_->active_tree(), 1); 463 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 464 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2); 465 466 host_impl_->SetViewportSize(gfx::Size(200, 200)); 467 root_layer->SetBounds(gfx::Size(100, 100)); 468 469 delegated_renderer_layer->SetPosition(gfx::Point(20, 20)); 470 delegated_renderer_layer->SetBounds(gfx::Size(75, 75)); 471 delegated_renderer_layer->SetContentBounds(gfx::Size(75, 75)); 472 delegated_renderer_layer->SetDrawsContent(true); 473 gfx::Transform transform; 474 transform.Scale(2.0, 2.0); 475 transform.Translate(8.0, 8.0); 476 delegated_renderer_layer->SetTransform(transform); 477 478 ScopedPtrVector<RenderPass> delegated_render_passes; 479 480 gfx::Size child_pass_content_bounds(7, 7); 481 gfx::Rect child_pass_rect(20, 20, 7, 7); 482 gfx::Transform child_pass_transform; 483 child_pass_transform.Scale(0.8f, 0.8f); 484 child_pass_transform.Translate(9.0, 9.0); 485 gfx::Rect child_pass_clip_rect(21, 21, 3, 3); 486 bool child_pass_clipped = false; 487 488 { 489 TestRenderPass* pass = AddRenderPass( 490 &delegated_render_passes, 491 RenderPass::Id(10, 7), 492 child_pass_rect, 493 gfx::Transform()); 494 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 495 AppendQuadsData data(pass->id); 496 SharedQuadState* shared_quad_state = quad_sink.UseSharedQuadState( 497 SharedQuadState::Create()); 498 shared_quad_state->SetAll( 499 child_pass_transform, 500 child_pass_content_bounds, 501 child_pass_rect, 502 child_pass_clip_rect, 503 child_pass_clipped, 504 1.f); 505 506 scoped_ptr<SolidColorDrawQuad> color_quad; 507 color_quad = SolidColorDrawQuad::Create(); 508 color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false); 509 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 510 511 color_quad = SolidColorDrawQuad::Create(); 512 color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false); 513 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 514 } 515 516 gfx::Size root_pass_content_bounds(100, 100); 517 gfx::Rect root_pass_rect(0, 0, 100, 100); 518 gfx::Transform root_pass_transform; 519 root_pass_transform.Scale(1.5, 1.5); 520 root_pass_transform.Translate(7.0, 7.0); 521 gfx::Rect root_pass_clip_rect(10, 10, 35, 35); 522 bool root_pass_clipped = root_delegated_render_pass_is_clipped_; 523 524 TestRenderPass* pass = AddRenderPass( 525 &delegated_render_passes, 526 RenderPass::Id(9, 6), 527 root_pass_rect, 528 gfx::Transform()); 529 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 530 AppendQuadsData data(pass->id); 531 SharedQuadState* shared_quad_state = 532 quad_sink.UseSharedQuadState(SharedQuadState::Create()); 533 shared_quad_state->SetAll( 534 root_pass_transform, 535 root_pass_content_bounds, 536 root_pass_rect, 537 root_pass_clip_rect, 538 root_pass_clipped, 539 1.f); 540 541 scoped_ptr<RenderPassDrawQuad> render_pass_quad = 542 RenderPassDrawQuad::Create(); 543 render_pass_quad->SetNew( 544 shared_quad_state, 545 gfx::Rect(5, 5, 7, 7), // rect 546 RenderPass::Id(10, 7), // render_pass_id 547 false, // is_replica 548 0, // mask_resource_id 549 child_pass_rect, // contents_changed_since_last_frame 550 gfx::RectF(), // mask_uv_rect 551 FilterOperations(), // filters 552 FilterOperations()); // background_filters 553 quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); 554 555 scoped_ptr<SolidColorDrawQuad> color_quad; 556 color_quad = SolidColorDrawQuad::Create(); 557 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false); 558 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 559 560 color_quad = SolidColorDrawQuad::Create(); 561 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false); 562 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 563 564 color_quad = SolidColorDrawQuad::Create(); 565 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false); 566 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 567 568 color_quad = SolidColorDrawQuad::Create(); 569 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false); 570 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 571 572 delegated_renderer_layer->SetFrameDataForRenderPasses( 573 &delegated_render_passes); 574 575 // The RenderPasses should be taken by the layer. 576 EXPECT_EQ(0u, delegated_render_passes.size()); 577 578 root_layer_ = root_layer.get(); 579 delegated_renderer_layer_ = delegated_renderer_layer.get(); 580 581 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 582 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 583 } 584 585 void VerifyRenderPasses( 586 const LayerTreeHostImpl::FrameData& frame, 587 size_t num_render_passes, 588 const SharedQuadState** root_delegated_shared_quad_state, 589 const SharedQuadState** contrib_delegated_shared_quad_state) { 590 ASSERT_EQ(num_render_passes, frame.render_passes.size()); 591 // The contributing render pass in the DelegatedRendererLayer. 592 EXPECT_EQ(2, frame.render_passes[0]->id.layer_id); 593 EXPECT_EQ(1, frame.render_passes[0]->id.index); 594 // The root render pass. 595 EXPECT_EQ(1, frame.render_passes.back()->id.layer_id); 596 EXPECT_EQ(0, frame.render_passes.back()->id.index); 597 598 const QuadList& contrib_delegated_quad_list = 599 frame.render_passes[0]->quad_list; 600 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 601 602 const QuadList& root_delegated_quad_list = 603 frame.render_passes[1]->quad_list; 604 ASSERT_EQ(5u, root_delegated_quad_list.size()); 605 606 // All quads in a render pass should share the same state. 607 *contrib_delegated_shared_quad_state = 608 contrib_delegated_quad_list[0]->shared_quad_state; 609 EXPECT_EQ(*contrib_delegated_shared_quad_state, 610 contrib_delegated_quad_list[1]->shared_quad_state); 611 612 *root_delegated_shared_quad_state = 613 root_delegated_quad_list[0]->shared_quad_state; 614 EXPECT_EQ(*root_delegated_shared_quad_state, 615 root_delegated_quad_list[1]->shared_quad_state); 616 EXPECT_EQ(*root_delegated_shared_quad_state, 617 root_delegated_quad_list[2]->shared_quad_state); 618 EXPECT_EQ(*root_delegated_shared_quad_state, 619 root_delegated_quad_list[3]->shared_quad_state); 620 EXPECT_EQ(*root_delegated_shared_quad_state, 621 root_delegated_quad_list[4]->shared_quad_state); 622 623 EXPECT_NE(*contrib_delegated_shared_quad_state, 624 *root_delegated_shared_quad_state); 625 } 626 627 protected: 628 LayerImpl* root_layer_; 629 DelegatedRendererLayerImpl* delegated_renderer_layer_; 630 bool root_delegated_render_pass_is_clipped_; 631}; 632 633TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) { 634 root_delegated_render_pass_is_clipped_ = false; 635 SetUpTest(); 636 637 LayerTreeHostImpl::FrameData frame; 638 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 639 640 const SharedQuadState* root_delegated_shared_quad_state = NULL; 641 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 642 VerifyRenderPasses( 643 frame, 644 2, 645 &root_delegated_shared_quad_state, 646 &contrib_delegated_shared_quad_state); 647 648 // When the quads don't have a clip of their own, the clip rect is set to 649 // the drawable_content_rect of the delegated renderer layer. 650 EXPECT_EQ(delegated_renderer_layer_->drawable_content_rect().ToString(), 651 root_delegated_shared_quad_state->clip_rect.ToString()); 652 653 // Even though the quads in the root pass have no clip of their own, they 654 // inherit the clip rect from the delegated renderer layer if it does not 655 // own a surface. 656 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 657 658 gfx::Transform expected; 659 // Device scale factor is 2. 660 expected.Scale(2.0, 2.0); 661 // This is the transform from the layer's space to its target. 662 // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5 663 expected.Translate(-17.5, -17.5); 664 expected.Scale(2.0, 2.0); 665 expected.Translate(8.0, 8.0); 666 // The frame has size 100x100 but the layer's bounds are 75x75. 667 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 668 // This is the transform within the source frame. 669 expected.Scale(1.5, 1.5); 670 expected.Translate(7.0, 7.0); 671 EXPECT_TRANSFORMATION_MATRIX_EQ( 672 expected, root_delegated_shared_quad_state->content_to_target_transform); 673 674 // The contributing render pass should not be transformed from its input. 675 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 676 contrib_delegated_shared_quad_state->clip_rect.ToString()); 677 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 678 expected.MakeIdentity(); 679 expected.Scale(0.8f, 0.8f); 680 expected.Translate(9.0, 9.0); 681 EXPECT_TRANSFORMATION_MATRIX_EQ( 682 expected, 683 contrib_delegated_shared_quad_state->content_to_target_transform); 684 685 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 686 host_impl_->DidDrawAllLayers(frame); 687} 688 689TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) { 690 root_delegated_render_pass_is_clipped_ = true; 691 SetUpTest(); 692 693 LayerTreeHostImpl::FrameData frame; 694 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 695 696 const SharedQuadState* root_delegated_shared_quad_state = NULL; 697 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 698 VerifyRenderPasses( 699 frame, 700 2, 701 &root_delegated_shared_quad_state, 702 &contrib_delegated_shared_quad_state); 703 704 // Since the quads have a clip_rect it should be modified by delegated 705 // renderer layer's draw_transform. 706 // The position of the resulting clip_rect is: 707 // (clip rect position (10) * scale to layer (75/100) + translate (8)) * 708 // layer scale (2) + layer position (20) = 51 709 // But the layer is centered, so: 51 - (75 / 2) = 51 - 75 / 2 = 13.5 710 // The device scale is 2, so everything gets doubled, giving 27. 711 // 712 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 713 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. The device 714 // scale doubles this to 105. 715 EXPECT_EQ(gfx::Rect(27, 27, 105, 105).ToString(), 716 root_delegated_shared_quad_state->clip_rect.ToString()); 717 718 // The quads had a clip and it should be preserved. 719 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 720 721 gfx::Transform expected; 722 // Device scale factor is 2. 723 expected.Scale(2.0, 2.0); 724 // This is the transform from the layer's space to its target. 725 // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5 726 expected.Translate(-17.5, -17.5); 727 expected.Scale(2.0, 2.0); 728 expected.Translate(8.0, 8.0); 729 // The frame has size 100x100 but the layer's bounds are 75x75. 730 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 731 // This is the transform within the source frame. 732 expected.Scale(1.5, 1.5); 733 expected.Translate(7.0, 7.0); 734 EXPECT_TRANSFORMATION_MATRIX_EQ( 735 expected, root_delegated_shared_quad_state->content_to_target_transform); 736 737 // The contributing render pass should not be transformed from its input. 738 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 739 contrib_delegated_shared_quad_state->clip_rect.ToString()); 740 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 741 expected.MakeIdentity(); 742 expected.Scale(0.8f, 0.8f); 743 expected.Translate(9.0, 9.0); 744 EXPECT_TRANSFORMATION_MATRIX_EQ( 745 expected, 746 contrib_delegated_shared_quad_state->content_to_target_transform); 747 748 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 749 host_impl_->DidDrawAllLayers(frame); 750} 751 752TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) { 753 root_delegated_render_pass_is_clipped_ = false; 754 SetUpTest(); 755 756 delegated_renderer_layer_->SetForceRenderSurface(true); 757 758 LayerTreeHostImpl::FrameData frame; 759 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 760 761 const SharedQuadState* root_delegated_shared_quad_state = NULL; 762 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 763 VerifyRenderPasses( 764 frame, 765 3, 766 &root_delegated_shared_quad_state, 767 &contrib_delegated_shared_quad_state); 768 769 // When the layer owns a surface, then its position and translation are not 770 // a part of its draw transform. 771 // The position of the resulting clip_rect is: 772 // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15 773 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 774 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. 775 EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(), 776 root_delegated_shared_quad_state->clip_rect.ToString()); 777 778 // Since the layer owns a surface it doesn't need to clip its quads, so 779 // unclipped quads remain unclipped. 780 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 781 782 gfx::Transform expected; 783 // Device scale factor is 2. 784 expected.Scale(2.0, 2.0); 785 // The frame has size 100x100 but the layer's bounds are 75x75. 786 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 787 // This is the transform within the source frame. 788 expected.Scale(1.5, 1.5); 789 expected.Translate(7.0, 7.0); 790 EXPECT_TRANSFORMATION_MATRIX_EQ( 791 expected, root_delegated_shared_quad_state->content_to_target_transform); 792 793 // The contributing render pass should not be transformed from its input. 794 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 795 contrib_delegated_shared_quad_state->clip_rect.ToString()); 796 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 797 expected.MakeIdentity(); 798 expected.Scale(0.8f, 0.8f); 799 expected.Translate(9.0, 9.0); 800 EXPECT_TRANSFORMATION_MATRIX_EQ( 801 expected, 802 contrib_delegated_shared_quad_state->content_to_target_transform); 803 804 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 805 host_impl_->DidDrawAllLayers(frame); 806} 807 808TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) { 809 root_delegated_render_pass_is_clipped_ = true; 810 SetUpTest(); 811 812 delegated_renderer_layer_->SetForceRenderSurface(true); 813 814 LayerTreeHostImpl::FrameData frame; 815 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 816 817 const SharedQuadState* root_delegated_shared_quad_state = NULL; 818 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 819 VerifyRenderPasses( 820 frame, 821 3, 822 &root_delegated_shared_quad_state, 823 &contrib_delegated_shared_quad_state); 824 825 // When the layer owns a surface, then its position and translation are not 826 // a part of its draw transform. 827 // The position of the resulting clip_rect is: 828 // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15 829 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 830 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. 831 EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(), 832 root_delegated_shared_quad_state->clip_rect.ToString()); 833 834 // The quads had a clip and it should be preserved. 835 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 836 837 gfx::Transform expected; 838 // Device scale factor is 2. 839 expected.Scale(2.0, 2.0); 840 // The frame has size 100x100 but the layer's bounds are 75x75. 841 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 842 // This is the transform within the source frame. 843 expected.Scale(1.5, 1.5); 844 expected.Translate(7.0, 7.0); 845 EXPECT_TRANSFORMATION_MATRIX_EQ( 846 expected, root_delegated_shared_quad_state->content_to_target_transform); 847 848 // The contributing render pass should not be transformed from its input. 849 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 850 contrib_delegated_shared_quad_state->clip_rect.ToString()); 851 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 852 expected.MakeIdentity(); 853 expected.Scale(0.8f, 0.8f); 854 expected.Translate(9.0, 9.0); 855 EXPECT_TRANSFORMATION_MATRIX_EQ( 856 expected, 857 contrib_delegated_shared_quad_state->content_to_target_transform); 858 859 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 860 host_impl_->DidDrawAllLayers(frame); 861} 862 863class DelegatedRendererLayerImplTestClip 864 : public DelegatedRendererLayerImplTest { 865 public: 866 void SetUpTest() { 867 scoped_ptr<LayerImpl> root_layer = 868 LayerImpl::Create(host_impl_->active_tree(), 1); 869 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 870 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2); 871 scoped_ptr<LayerImpl> clip_layer = 872 LayerImpl::Create(host_impl_->active_tree(), 3); 873 scoped_ptr<LayerImpl> origin_layer = 874 LayerImpl::Create(host_impl_->active_tree(), 4); 875 876 host_impl_->SetViewportSize(gfx::Size(100, 100)); 877 root_layer->SetBounds(gfx::Size(100, 100)); 878 879 delegated_renderer_layer->SetPosition(gfx::Point(20, 20)); 880 delegated_renderer_layer->SetBounds(gfx::Size(50, 50)); 881 delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50)); 882 delegated_renderer_layer->SetDrawsContent(true); 883 884 ScopedPtrVector<RenderPass> delegated_render_passes; 885 886 gfx::Size child_pass_content_bounds(7, 7); 887 gfx::Rect child_pass_rect(20, 20, 7, 7); 888 gfx::Transform child_pass_transform; 889 gfx::Rect child_pass_clip_rect(21, 21, 3, 3); 890 bool child_pass_clipped = false; 891 892 { 893 TestRenderPass* pass = AddRenderPass( 894 &delegated_render_passes, 895 RenderPass::Id(10, 7), 896 child_pass_rect, 897 gfx::Transform()); 898 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 899 AppendQuadsData data(pass->id); 900 SharedQuadState* shared_quad_state = 901 quad_sink.UseSharedQuadState(SharedQuadState::Create()); 902 shared_quad_state->SetAll( 903 child_pass_transform, 904 child_pass_content_bounds, 905 child_pass_rect, 906 child_pass_clip_rect, 907 child_pass_clipped, 908 1.f); 909 910 scoped_ptr<SolidColorDrawQuad> color_quad; 911 color_quad = SolidColorDrawQuad::Create(); 912 color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false); 913 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 914 915 color_quad = SolidColorDrawQuad::Create(); 916 color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false); 917 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 918 } 919 920 gfx::Size root_pass_content_bounds(50, 50); 921 gfx::Rect root_pass_rect(0, 0, 50, 50); 922 gfx::Transform root_pass_transform; 923 gfx::Rect root_pass_clip_rect(5, 5, 40, 40); 924 bool root_pass_clipped = root_delegated_render_pass_is_clipped_; 925 926 TestRenderPass* pass = AddRenderPass( 927 &delegated_render_passes, 928 RenderPass::Id(9, 6), 929 root_pass_rect, 930 gfx::Transform()); 931 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 932 AppendQuadsData data(pass->id); 933 SharedQuadState* shared_quad_state = 934 quad_sink.UseSharedQuadState(SharedQuadState::Create()); 935 shared_quad_state->SetAll(root_pass_transform, 936 root_pass_content_bounds, 937 root_pass_rect, 938 root_pass_clip_rect, 939 root_pass_clipped, 940 1.f); 941 942 scoped_ptr<RenderPassDrawQuad> render_pass_quad = 943 RenderPassDrawQuad::Create(); 944 render_pass_quad->SetNew( 945 shared_quad_state, 946 gfx::Rect(5, 5, 7, 7), // rect 947 RenderPass::Id(10, 7), // render_pass_id 948 false, // is_replica 949 0, // mask_resource_id 950 child_pass_rect, // contents_changed_since_last_frame 951 gfx::RectF(), // mask_uv_rect 952 FilterOperations(), // filters 953 FilterOperations()); // background_filters 954 quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); 955 956 scoped_ptr<SolidColorDrawQuad> color_quad; 957 color_quad = SolidColorDrawQuad::Create(); 958 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false); 959 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 960 961 color_quad = SolidColorDrawQuad::Create(); 962 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false); 963 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 964 965 color_quad = SolidColorDrawQuad::Create(); 966 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false); 967 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 968 969 color_quad = SolidColorDrawQuad::Create(); 970 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false); 971 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 972 973 delegated_renderer_layer->SetFrameDataForRenderPasses( 974 &delegated_render_passes); 975 976 // The RenderPasses should be taken by the layer. 977 EXPECT_EQ(0u, delegated_render_passes.size()); 978 979 root_layer_ = root_layer.get(); 980 delegated_renderer_layer_ = delegated_renderer_layer.get(); 981 982 if (clip_delegated_renderer_layer_) { 983 gfx::Rect clip_rect(21, 27, 23, 21); 984 985 clip_layer->SetPosition(clip_rect.origin()); 986 clip_layer->SetBounds(clip_rect.size()); 987 clip_layer->SetContentBounds(clip_rect.size()); 988 clip_layer->SetMasksToBounds(true); 989 990 origin_layer->SetPosition( 991 gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin())); 992 993 origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 994 clip_layer->AddChild(origin_layer.Pass()); 995 root_layer->AddChild(clip_layer.Pass()); 996 } else { 997 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 998 } 999 1000 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 1001 } 1002 1003 protected: 1004 LayerImpl* root_layer_; 1005 DelegatedRendererLayerImpl* delegated_renderer_layer_; 1006 bool root_delegated_render_pass_is_clipped_; 1007 bool clip_delegated_renderer_layer_; 1008}; 1009 1010TEST_F(DelegatedRendererLayerImplTestClip, 1011 QuadsUnclipped_LayerUnclipped_NoSurface) { 1012 root_delegated_render_pass_is_clipped_ = false; 1013 clip_delegated_renderer_layer_ = false; 1014 SetUpTest(); 1015 1016 LayerTreeHostImpl::FrameData frame; 1017 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1018 1019 ASSERT_EQ(2u, frame.render_passes.size()); 1020 const QuadList& contrib_delegated_quad_list = 1021 frame.render_passes[0]->quad_list; 1022 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1023 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1024 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1025 const SharedQuadState* root_delegated_shared_quad_state = 1026 root_delegated_quad_list[0]->shared_quad_state; 1027 1028 // When the quads don't have a clip of their own, the clip rect is set to 1029 // the drawable_content_rect of the delegated renderer layer. 1030 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(), 1031 root_delegated_shared_quad_state->clip_rect.ToString()); 1032 // Quads are clipped to the delegated renderer layer. 1033 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1034 1035 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1036 host_impl_->DidDrawAllLayers(frame); 1037} 1038 1039TEST_F(DelegatedRendererLayerImplTestClip, 1040 QuadsClipped_LayerUnclipped_NoSurface) { 1041 root_delegated_render_pass_is_clipped_ = true; 1042 clip_delegated_renderer_layer_ = false; 1043 SetUpTest(); 1044 1045 LayerTreeHostImpl::FrameData frame; 1046 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1047 1048 ASSERT_EQ(2u, frame.render_passes.size()); 1049 const QuadList& contrib_delegated_quad_list = 1050 frame.render_passes[0]->quad_list; 1051 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1052 const QuadList& root_delegated_quad_list = 1053 frame.render_passes[1]->quad_list; 1054 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1055 const SharedQuadState* root_delegated_shared_quad_state = 1056 root_delegated_quad_list[0]->shared_quad_state; 1057 1058 // When the quads have a clip of their own, it is used. 1059 EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(), 1060 root_delegated_shared_quad_state->clip_rect.ToString()); 1061 // Quads came with a clip rect. 1062 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1063 1064 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1065 host_impl_->DidDrawAllLayers(frame); 1066} 1067 1068TEST_F(DelegatedRendererLayerImplTestClip, 1069 QuadsUnclipped_LayerClipped_NoSurface) { 1070 root_delegated_render_pass_is_clipped_ = false; 1071 clip_delegated_renderer_layer_ = true; 1072 SetUpTest(); 1073 1074 LayerTreeHostImpl::FrameData frame; 1075 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1076 1077 ASSERT_EQ(2u, frame.render_passes.size()); 1078 const QuadList& contrib_delegated_quad_list = 1079 frame.render_passes[0]->quad_list; 1080 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1081 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1082 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1083 const SharedQuadState* root_delegated_shared_quad_state = 1084 root_delegated_quad_list[0]->shared_quad_state; 1085 1086 // When the quads don't have a clip of their own, the clip rect is set to 1087 // the drawable_content_rect of the delegated renderer layer. When the layer 1088 // is clipped, that should be seen in the quads' clip_rect. 1089 EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(), 1090 root_delegated_shared_quad_state->clip_rect.ToString()); 1091 // Quads are clipped to the delegated renderer layer. 1092 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1093 1094 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1095 host_impl_->DidDrawAllLayers(frame); 1096} 1097 1098TEST_F(DelegatedRendererLayerImplTestClip, 1099 QuadsClipped_LayerClipped_NoSurface) { 1100 root_delegated_render_pass_is_clipped_ = true; 1101 clip_delegated_renderer_layer_ = true; 1102 SetUpTest(); 1103 1104 LayerTreeHostImpl::FrameData frame; 1105 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1106 1107 ASSERT_EQ(2u, frame.render_passes.size()); 1108 const QuadList& contrib_delegated_quad_list = 1109 frame.render_passes[0]->quad_list; 1110 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1111 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1112 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1113 const SharedQuadState* root_delegated_shared_quad_state = 1114 root_delegated_quad_list[0]->shared_quad_state; 1115 1116 // When the quads have a clip of their own, it is used, but it is 1117 // combined with the clip rect of the delegated renderer layer. 1118 EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(), 1119 root_delegated_shared_quad_state->clip_rect.ToString()); 1120 // Quads came with a clip rect. 1121 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1122 1123 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1124 host_impl_->DidDrawAllLayers(frame); 1125} 1126 1127TEST_F(DelegatedRendererLayerImplTestClip, 1128 QuadsUnclipped_LayerUnclipped_Surface) { 1129 root_delegated_render_pass_is_clipped_ = false; 1130 clip_delegated_renderer_layer_ = false; 1131 SetUpTest(); 1132 1133 delegated_renderer_layer_->SetForceRenderSurface(true); 1134 1135 LayerTreeHostImpl::FrameData frame; 1136 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1137 1138 ASSERT_EQ(3u, frame.render_passes.size()); 1139 const QuadList& contrib_delegated_quad_list = 1140 frame.render_passes[0]->quad_list; 1141 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1142 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1143 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1144 const SharedQuadState* root_delegated_shared_quad_state = 1145 root_delegated_quad_list[0]->shared_quad_state; 1146 1147 // When the layer owns a surface, the quads don't need to be clipped 1148 // further than they already specify. If they aren't clipped, then their 1149 // clip rect is ignored, and they are not set as clipped. 1150 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 1151 1152 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1153 host_impl_->DidDrawAllLayers(frame); 1154} 1155 1156TEST_F(DelegatedRendererLayerImplTestClip, 1157 QuadsClipped_LayerUnclipped_Surface) { 1158 root_delegated_render_pass_is_clipped_ = true; 1159 clip_delegated_renderer_layer_ = false; 1160 SetUpTest(); 1161 1162 delegated_renderer_layer_->SetForceRenderSurface(true); 1163 1164 LayerTreeHostImpl::FrameData frame; 1165 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1166 1167 ASSERT_EQ(3u, frame.render_passes.size()); 1168 const QuadList& contrib_delegated_quad_list = 1169 frame.render_passes[0]->quad_list; 1170 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1171 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1172 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1173 const SharedQuadState* root_delegated_shared_quad_state = 1174 root_delegated_quad_list[0]->shared_quad_state; 1175 1176 // When the quads have a clip of their own, it is used. 1177 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(), 1178 root_delegated_shared_quad_state->clip_rect.ToString()); 1179 // Quads came with a clip rect. 1180 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1181 1182 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1183 host_impl_->DidDrawAllLayers(frame); 1184} 1185 1186TEST_F(DelegatedRendererLayerImplTestClip, 1187 QuadsUnclipped_LayerClipped_Surface) { 1188 root_delegated_render_pass_is_clipped_ = false; 1189 clip_delegated_renderer_layer_ = true; 1190 SetUpTest(); 1191 1192 delegated_renderer_layer_->SetForceRenderSurface(true); 1193 1194 LayerTreeHostImpl::FrameData frame; 1195 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1196 1197 ASSERT_EQ(3u, frame.render_passes.size()); 1198 const QuadList& contrib_delegated_quad_list = 1199 frame.render_passes[0]->quad_list; 1200 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1201 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1202 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1203 const SharedQuadState* root_delegated_shared_quad_state = 1204 root_delegated_quad_list[0]->shared_quad_state; 1205 1206 // When the layer owns a surface, the quads don't need to be clipped 1207 // further than they already specify. If they aren't clipped, then their 1208 // clip rect is ignored, and they are not set as clipped. 1209 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 1210 1211 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1212 host_impl_->DidDrawAllLayers(frame); 1213} 1214 1215TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) { 1216 root_delegated_render_pass_is_clipped_ = true; 1217 clip_delegated_renderer_layer_ = true; 1218 SetUpTest(); 1219 1220 delegated_renderer_layer_->SetForceRenderSurface(true); 1221 1222 LayerTreeHostImpl::FrameData frame; 1223 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1224 1225 ASSERT_EQ(3u, frame.render_passes.size()); 1226 const QuadList& contrib_delegated_quad_list = 1227 frame.render_passes[0]->quad_list; 1228 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1229 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1230 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1231 const SharedQuadState* root_delegated_shared_quad_state = 1232 root_delegated_quad_list[0]->shared_quad_state; 1233 1234 // When the quads have a clip of their own, it is used, but it is 1235 // combined with the clip rect of the delegated renderer layer. If the 1236 // layer owns a surface, then it does not have a clip rect of its own. 1237 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(), 1238 root_delegated_shared_quad_state->clip_rect.ToString()); 1239 // Quads came with a clip rect. 1240 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1241 1242 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1243 host_impl_->DidDrawAllLayers(frame); 1244} 1245 1246TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) { 1247 scoped_ptr<LayerImpl> root_layer = LayerImpl::Create( 1248 host_impl_->active_tree(), 1).PassAs<LayerImpl>(); 1249 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 1250 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4); 1251 1252 host_impl_->SetViewportSize(gfx::Size(100, 100)); 1253 1254 delegated_renderer_layer->SetPosition(gfx::Point(3, 3)); 1255 delegated_renderer_layer->SetBounds(gfx::Size(10, 10)); 1256 delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10)); 1257 delegated_renderer_layer->SetDrawsContent(true); 1258 1259 ScopedPtrVector<RenderPass> delegated_render_passes; 1260 TestRenderPass* pass1 = AddRenderPass( 1261 &delegated_render_passes, 1262 RenderPass::Id(9, 6), 1263 gfx::Rect(0, 0, 10, 10), 1264 gfx::Transform()); 1265 AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u); 1266 1267 // This render pass isn't part of the frame. 1268 scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create()); 1269 missing_pass->SetNew(RenderPass::Id(9, 7), 1270 gfx::Rect(7, 7, 7, 7), 1271 gfx::Rect(7, 7, 7, 7), 1272 gfx::Transform()); 1273 1274 // But a render pass quad refers to it. 1275 AddRenderPassQuad(pass1, missing_pass.get()); 1276 1277 delegated_renderer_layer->SetFrameDataForRenderPasses( 1278 &delegated_render_passes); 1279 1280 // The RenderPasses should be taken by the layer. 1281 EXPECT_EQ(0u, delegated_render_passes.size()); 1282 1283 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 1284 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 1285 1286 LayerTreeHostImpl::FrameData frame; 1287 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1288 1289 // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad. 1290 ASSERT_EQ(1u, frame.render_passes.size()); 1291 ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size()); 1292 EXPECT_EQ(DrawQuad::SOLID_COLOR, 1293 frame.render_passes[0]->quad_list[0]->material); 1294 1295 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1296 host_impl_->DidDrawAllLayers(frame); 1297} 1298 1299} // namespace 1300} // namespace cc 1301