delegated_renderer_layer_impl_unittest.cc revision 58537e28ecd584eab876aee8be7156509866d23a
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.8, 0.8); 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 skia::RefPtr<SkImageFilter>(), // filter 553 FilterOperations()); // background_filters 554 quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); 555 556 scoped_ptr<SolidColorDrawQuad> color_quad; 557 color_quad = SolidColorDrawQuad::Create(); 558 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false); 559 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 560 561 color_quad = SolidColorDrawQuad::Create(); 562 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false); 563 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 564 565 color_quad = SolidColorDrawQuad::Create(); 566 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false); 567 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 568 569 color_quad = SolidColorDrawQuad::Create(); 570 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false); 571 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 572 573 delegated_renderer_layer->SetFrameDataForRenderPasses( 574 &delegated_render_passes); 575 576 // The RenderPasses should be taken by the layer. 577 EXPECT_EQ(0u, delegated_render_passes.size()); 578 579 root_layer_ = root_layer.get(); 580 delegated_renderer_layer_ = delegated_renderer_layer.get(); 581 582 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 583 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 584 } 585 586 void VerifyRenderPasses( 587 const LayerTreeHostImpl::FrameData& frame, 588 size_t num_render_passes, 589 const SharedQuadState** root_delegated_shared_quad_state, 590 const SharedQuadState** contrib_delegated_shared_quad_state) { 591 ASSERT_EQ(num_render_passes, frame.render_passes.size()); 592 // The contributing render pass in the DelegatedRendererLayer. 593 EXPECT_EQ(2, frame.render_passes[0]->id.layer_id); 594 EXPECT_EQ(1, frame.render_passes[0]->id.index); 595 // The root render pass. 596 EXPECT_EQ(1, frame.render_passes.back()->id.layer_id); 597 EXPECT_EQ(0, frame.render_passes.back()->id.index); 598 599 const QuadList& contrib_delegated_quad_list = 600 frame.render_passes[0]->quad_list; 601 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 602 603 const QuadList& root_delegated_quad_list = 604 frame.render_passes[1]->quad_list; 605 ASSERT_EQ(5u, root_delegated_quad_list.size()); 606 607 // All quads in a render pass should share the same state. 608 *contrib_delegated_shared_quad_state = 609 contrib_delegated_quad_list[0]->shared_quad_state; 610 EXPECT_EQ(*contrib_delegated_shared_quad_state, 611 contrib_delegated_quad_list[1]->shared_quad_state); 612 613 *root_delegated_shared_quad_state = 614 root_delegated_quad_list[0]->shared_quad_state; 615 EXPECT_EQ(*root_delegated_shared_quad_state, 616 root_delegated_quad_list[1]->shared_quad_state); 617 EXPECT_EQ(*root_delegated_shared_quad_state, 618 root_delegated_quad_list[2]->shared_quad_state); 619 EXPECT_EQ(*root_delegated_shared_quad_state, 620 root_delegated_quad_list[3]->shared_quad_state); 621 EXPECT_EQ(*root_delegated_shared_quad_state, 622 root_delegated_quad_list[4]->shared_quad_state); 623 624 EXPECT_NE(*contrib_delegated_shared_quad_state, 625 *root_delegated_shared_quad_state); 626 } 627 628 protected: 629 LayerImpl* root_layer_; 630 DelegatedRendererLayerImpl* delegated_renderer_layer_; 631 bool root_delegated_render_pass_is_clipped_; 632}; 633 634TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) { 635 root_delegated_render_pass_is_clipped_ = false; 636 SetUpTest(); 637 638 LayerTreeHostImpl::FrameData frame; 639 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 640 641 const SharedQuadState* root_delegated_shared_quad_state = NULL; 642 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 643 VerifyRenderPasses( 644 frame, 645 2, 646 &root_delegated_shared_quad_state, 647 &contrib_delegated_shared_quad_state); 648 649 // When the quads don't have a clip of their own, the clip rect is set to 650 // the drawable_content_rect of the delegated renderer layer. 651 EXPECT_EQ(delegated_renderer_layer_->drawable_content_rect().ToString(), 652 root_delegated_shared_quad_state->clip_rect.ToString()); 653 654 // Even though the quads in the root pass have no clip of their own, they 655 // inherit the clip rect from the delegated renderer layer if it does not 656 // own a surface. 657 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 658 659 gfx::Transform expected; 660 // Device scale factor is 2. 661 expected.Scale(2.0, 2.0); 662 // This is the transform from the layer's space to its target. 663 // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5 664 expected.Translate(-17.5, -17.5); 665 expected.Scale(2.0, 2.0); 666 expected.Translate(8.0, 8.0); 667 // The frame has size 100x100 but the layer's bounds are 75x75. 668 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 669 // This is the transform within the source frame. 670 expected.Scale(1.5, 1.5); 671 expected.Translate(7.0, 7.0); 672 EXPECT_TRANSFORMATION_MATRIX_EQ( 673 expected, root_delegated_shared_quad_state->content_to_target_transform); 674 675 // The contributing render pass should not be transformed from its input. 676 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 677 contrib_delegated_shared_quad_state->clip_rect.ToString()); 678 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 679 expected.MakeIdentity(); 680 expected.Scale(0.8, 0.8); 681 expected.Translate(9.0, 9.0); 682 EXPECT_TRANSFORMATION_MATRIX_EQ( 683 expected, 684 contrib_delegated_shared_quad_state->content_to_target_transform); 685 686 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 687 host_impl_->DidDrawAllLayers(frame); 688} 689 690TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) { 691 root_delegated_render_pass_is_clipped_ = true; 692 SetUpTest(); 693 694 LayerTreeHostImpl::FrameData frame; 695 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 696 697 const SharedQuadState* root_delegated_shared_quad_state = NULL; 698 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 699 VerifyRenderPasses( 700 frame, 701 2, 702 &root_delegated_shared_quad_state, 703 &contrib_delegated_shared_quad_state); 704 705 // Since the quads have a clip_rect it should be modified by delegated 706 // renderer layer's draw_transform. 707 // The position of the resulting clip_rect is: 708 // (clip rect position (10) * scale to layer (75/100) + translate (8)) * 709 // layer scale (2) + layer position (20) = 51 710 // But the layer is centered, so: 51 - (75 / 2) = 51 - 75 / 2 = 13.5 711 // The device scale is 2, so everything gets doubled, giving 27. 712 // 713 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 714 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. The device 715 // scale doubles this to 105. 716 EXPECT_EQ(gfx::Rect(27, 27, 105, 105).ToString(), 717 root_delegated_shared_quad_state->clip_rect.ToString()); 718 719 // The quads had a clip and it should be preserved. 720 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 721 722 gfx::Transform expected; 723 // Device scale factor is 2. 724 expected.Scale(2.0, 2.0); 725 // This is the transform from the layer's space to its target. 726 // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5 727 expected.Translate(-17.5, -17.5); 728 expected.Scale(2.0, 2.0); 729 expected.Translate(8.0, 8.0); 730 // The frame has size 100x100 but the layer's bounds are 75x75. 731 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 732 // This is the transform within the source frame. 733 expected.Scale(1.5, 1.5); 734 expected.Translate(7.0, 7.0); 735 EXPECT_TRANSFORMATION_MATRIX_EQ( 736 expected, root_delegated_shared_quad_state->content_to_target_transform); 737 738 // The contributing render pass should not be transformed from its input. 739 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 740 contrib_delegated_shared_quad_state->clip_rect.ToString()); 741 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 742 expected.MakeIdentity(); 743 expected.Scale(0.8, 0.8); 744 expected.Translate(9.0, 9.0); 745 EXPECT_TRANSFORMATION_MATRIX_EQ( 746 expected, 747 contrib_delegated_shared_quad_state->content_to_target_transform); 748 749 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 750 host_impl_->DidDrawAllLayers(frame); 751} 752 753TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) { 754 root_delegated_render_pass_is_clipped_ = false; 755 SetUpTest(); 756 757 delegated_renderer_layer_->SetForceRenderSurface(true); 758 759 LayerTreeHostImpl::FrameData frame; 760 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 761 762 const SharedQuadState* root_delegated_shared_quad_state = NULL; 763 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 764 VerifyRenderPasses( 765 frame, 766 3, 767 &root_delegated_shared_quad_state, 768 &contrib_delegated_shared_quad_state); 769 770 // When the layer owns a surface, then its position and translation are not 771 // a part of its draw transform. 772 // The position of the resulting clip_rect is: 773 // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15 774 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 775 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. 776 EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(), 777 root_delegated_shared_quad_state->clip_rect.ToString()); 778 779 // Since the layer owns a surface it doesn't need to clip its quads, so 780 // unclipped quads remain unclipped. 781 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 782 783 gfx::Transform expected; 784 // Device scale factor is 2. 785 expected.Scale(2.0, 2.0); 786 // The frame has size 100x100 but the layer's bounds are 75x75. 787 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 788 // This is the transform within the source frame. 789 expected.Scale(1.5, 1.5); 790 expected.Translate(7.0, 7.0); 791 EXPECT_TRANSFORMATION_MATRIX_EQ( 792 expected, root_delegated_shared_quad_state->content_to_target_transform); 793 794 // The contributing render pass should not be transformed from its input. 795 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 796 contrib_delegated_shared_quad_state->clip_rect.ToString()); 797 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 798 expected.MakeIdentity(); 799 expected.Scale(0.8, 0.8); 800 expected.Translate(9.0, 9.0); 801 EXPECT_TRANSFORMATION_MATRIX_EQ( 802 expected, 803 contrib_delegated_shared_quad_state->content_to_target_transform); 804 805 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 806 host_impl_->DidDrawAllLayers(frame); 807} 808 809TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) { 810 root_delegated_render_pass_is_clipped_ = true; 811 SetUpTest(); 812 813 delegated_renderer_layer_->SetForceRenderSurface(true); 814 815 LayerTreeHostImpl::FrameData frame; 816 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 817 818 const SharedQuadState* root_delegated_shared_quad_state = NULL; 819 const SharedQuadState* contrib_delegated_shared_quad_state = NULL; 820 VerifyRenderPasses( 821 frame, 822 3, 823 &root_delegated_shared_quad_state, 824 &contrib_delegated_shared_quad_state); 825 826 // When the layer owns a surface, then its position and translation are not 827 // a part of its draw transform. 828 // The position of the resulting clip_rect is: 829 // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15 830 // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from 831 // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. 832 EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(), 833 root_delegated_shared_quad_state->clip_rect.ToString()); 834 835 // The quads had a clip and it should be preserved. 836 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 837 838 gfx::Transform expected; 839 // Device scale factor is 2. 840 expected.Scale(2.0, 2.0); 841 // The frame has size 100x100 but the layer's bounds are 75x75. 842 expected.Scale(75.0 / 100.0, 75.0 / 100.0); 843 // This is the transform within the source frame. 844 expected.Scale(1.5, 1.5); 845 expected.Translate(7.0, 7.0); 846 EXPECT_TRANSFORMATION_MATRIX_EQ( 847 expected, root_delegated_shared_quad_state->content_to_target_transform); 848 849 // The contributing render pass should not be transformed from its input. 850 EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(), 851 contrib_delegated_shared_quad_state->clip_rect.ToString()); 852 EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped); 853 expected.MakeIdentity(); 854 expected.Scale(0.8, 0.8); 855 expected.Translate(9.0, 9.0); 856 EXPECT_TRANSFORMATION_MATRIX_EQ( 857 expected, 858 contrib_delegated_shared_quad_state->content_to_target_transform); 859 860 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 861 host_impl_->DidDrawAllLayers(frame); 862} 863 864class DelegatedRendererLayerImplTestClip 865 : public DelegatedRendererLayerImplTest { 866 public: 867 void SetUpTest() { 868 scoped_ptr<LayerImpl> root_layer = 869 LayerImpl::Create(host_impl_->active_tree(), 1); 870 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 871 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2); 872 scoped_ptr<LayerImpl> clip_layer = 873 LayerImpl::Create(host_impl_->active_tree(), 3); 874 scoped_ptr<LayerImpl> origin_layer = 875 LayerImpl::Create(host_impl_->active_tree(), 4); 876 877 host_impl_->SetViewportSize(gfx::Size(100, 100)); 878 root_layer->SetBounds(gfx::Size(100, 100)); 879 880 delegated_renderer_layer->SetPosition(gfx::Point(20, 20)); 881 delegated_renderer_layer->SetBounds(gfx::Size(50, 50)); 882 delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50)); 883 delegated_renderer_layer->SetDrawsContent(true); 884 885 ScopedPtrVector<RenderPass> delegated_render_passes; 886 887 gfx::Size child_pass_content_bounds(7, 7); 888 gfx::Rect child_pass_rect(20, 20, 7, 7); 889 gfx::Transform child_pass_transform; 890 gfx::Rect child_pass_clip_rect(21, 21, 3, 3); 891 bool child_pass_clipped = false; 892 893 { 894 TestRenderPass* pass = AddRenderPass( 895 &delegated_render_passes, 896 RenderPass::Id(10, 7), 897 child_pass_rect, 898 gfx::Transform()); 899 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 900 AppendQuadsData data(pass->id); 901 SharedQuadState* shared_quad_state = 902 quad_sink.UseSharedQuadState(SharedQuadState::Create()); 903 shared_quad_state->SetAll( 904 child_pass_transform, 905 child_pass_content_bounds, 906 child_pass_rect, 907 child_pass_clip_rect, 908 child_pass_clipped, 909 1.f); 910 911 scoped_ptr<SolidColorDrawQuad> color_quad; 912 color_quad = SolidColorDrawQuad::Create(); 913 color_quad->SetNew(shared_quad_state, gfx::Rect(20, 20, 3, 7), 1u, false); 914 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 915 916 color_quad = SolidColorDrawQuad::Create(); 917 color_quad->SetNew(shared_quad_state, gfx::Rect(23, 20, 4, 7), 1u, false); 918 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 919 } 920 921 gfx::Size root_pass_content_bounds(50, 50); 922 gfx::Rect root_pass_rect(0, 0, 50, 50); 923 gfx::Transform root_pass_transform; 924 gfx::Rect root_pass_clip_rect(5, 5, 40, 40); 925 bool root_pass_clipped = root_delegated_render_pass_is_clipped_; 926 927 TestRenderPass* pass = AddRenderPass( 928 &delegated_render_passes, 929 RenderPass::Id(9, 6), 930 root_pass_rect, 931 gfx::Transform()); 932 MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list); 933 AppendQuadsData data(pass->id); 934 SharedQuadState* shared_quad_state = 935 quad_sink.UseSharedQuadState(SharedQuadState::Create()); 936 shared_quad_state->SetAll(root_pass_transform, 937 root_pass_content_bounds, 938 root_pass_rect, 939 root_pass_clip_rect, 940 root_pass_clipped, 941 1.f); 942 943 scoped_ptr<RenderPassDrawQuad> render_pass_quad = 944 RenderPassDrawQuad::Create(); 945 render_pass_quad->SetNew( 946 shared_quad_state, 947 gfx::Rect(5, 5, 7, 7), // rect 948 RenderPass::Id(10, 7), // render_pass_id 949 false, // is_replica 950 0, // mask_resource_id 951 child_pass_rect, // contents_changed_since_last_frame 952 gfx::RectF(), // mask_uv_rect 953 FilterOperations(), // filters 954 skia::RefPtr<SkImageFilter>(), // filter 955 FilterOperations()); // background_filters 956 quad_sink.Append(render_pass_quad.PassAs<DrawQuad>(), &data); 957 958 scoped_ptr<SolidColorDrawQuad> color_quad; 959 color_quad = SolidColorDrawQuad::Create(); 960 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 0, 10, 10), 1u, false); 961 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 962 963 color_quad = SolidColorDrawQuad::Create(); 964 color_quad->SetNew(shared_quad_state, gfx::Rect(0, 10, 10, 10), 2u, false); 965 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 966 967 color_quad = SolidColorDrawQuad::Create(); 968 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 0, 10, 10), 3u, false); 969 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 970 971 color_quad = SolidColorDrawQuad::Create(); 972 color_quad->SetNew(shared_quad_state, gfx::Rect(10, 10, 10, 10), 4u, false); 973 quad_sink.Append(color_quad.PassAs<DrawQuad>(), &data); 974 975 delegated_renderer_layer->SetFrameDataForRenderPasses( 976 &delegated_render_passes); 977 978 // The RenderPasses should be taken by the layer. 979 EXPECT_EQ(0u, delegated_render_passes.size()); 980 981 root_layer_ = root_layer.get(); 982 delegated_renderer_layer_ = delegated_renderer_layer.get(); 983 984 if (clip_delegated_renderer_layer_) { 985 gfx::Rect clip_rect(21, 27, 23, 21); 986 987 clip_layer->SetPosition(clip_rect.origin()); 988 clip_layer->SetBounds(clip_rect.size()); 989 clip_layer->SetContentBounds(clip_rect.size()); 990 clip_layer->SetMasksToBounds(true); 991 992 origin_layer->SetPosition( 993 gfx::PointAtOffsetFromOrigin(-clip_rect.OffsetFromOrigin())); 994 995 origin_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 996 clip_layer->AddChild(origin_layer.Pass()); 997 root_layer->AddChild(clip_layer.Pass()); 998 } else { 999 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 1000 } 1001 1002 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 1003 } 1004 1005 protected: 1006 LayerImpl* root_layer_; 1007 DelegatedRendererLayerImpl* delegated_renderer_layer_; 1008 bool root_delegated_render_pass_is_clipped_; 1009 bool clip_delegated_renderer_layer_; 1010}; 1011 1012TEST_F(DelegatedRendererLayerImplTestClip, 1013 QuadsUnclipped_LayerUnclipped_NoSurface) { 1014 root_delegated_render_pass_is_clipped_ = false; 1015 clip_delegated_renderer_layer_ = false; 1016 SetUpTest(); 1017 1018 LayerTreeHostImpl::FrameData frame; 1019 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1020 1021 ASSERT_EQ(2u, frame.render_passes.size()); 1022 const QuadList& contrib_delegated_quad_list = 1023 frame.render_passes[0]->quad_list; 1024 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1025 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1026 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1027 const SharedQuadState* root_delegated_shared_quad_state = 1028 root_delegated_quad_list[0]->shared_quad_state; 1029 1030 // When the quads don't have a clip of their own, the clip rect is set to 1031 // the drawable_content_rect of the delegated renderer layer. 1032 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(), 1033 root_delegated_shared_quad_state->clip_rect.ToString()); 1034 // Quads are clipped to the delegated renderer layer. 1035 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1036 1037 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1038 host_impl_->DidDrawAllLayers(frame); 1039} 1040 1041TEST_F(DelegatedRendererLayerImplTestClip, 1042 QuadsClipped_LayerUnclipped_NoSurface) { 1043 root_delegated_render_pass_is_clipped_ = true; 1044 clip_delegated_renderer_layer_ = false; 1045 SetUpTest(); 1046 1047 LayerTreeHostImpl::FrameData frame; 1048 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1049 1050 ASSERT_EQ(2u, frame.render_passes.size()); 1051 const QuadList& contrib_delegated_quad_list = 1052 frame.render_passes[0]->quad_list; 1053 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1054 const QuadList& root_delegated_quad_list = 1055 frame.render_passes[1]->quad_list; 1056 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1057 const SharedQuadState* root_delegated_shared_quad_state = 1058 root_delegated_quad_list[0]->shared_quad_state; 1059 1060 // When the quads have a clip of their own, it is used. 1061 EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(), 1062 root_delegated_shared_quad_state->clip_rect.ToString()); 1063 // Quads came with a clip rect. 1064 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1065 1066 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1067 host_impl_->DidDrawAllLayers(frame); 1068} 1069 1070TEST_F(DelegatedRendererLayerImplTestClip, 1071 QuadsUnclipped_LayerClipped_NoSurface) { 1072 root_delegated_render_pass_is_clipped_ = false; 1073 clip_delegated_renderer_layer_ = true; 1074 SetUpTest(); 1075 1076 LayerTreeHostImpl::FrameData frame; 1077 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1078 1079 ASSERT_EQ(2u, frame.render_passes.size()); 1080 const QuadList& contrib_delegated_quad_list = 1081 frame.render_passes[0]->quad_list; 1082 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1083 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1084 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1085 const SharedQuadState* root_delegated_shared_quad_state = 1086 root_delegated_quad_list[0]->shared_quad_state; 1087 1088 // When the quads don't have a clip of their own, the clip rect is set to 1089 // the drawable_content_rect of the delegated renderer layer. When the layer 1090 // is clipped, that should be seen in the quads' clip_rect. 1091 EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(), 1092 root_delegated_shared_quad_state->clip_rect.ToString()); 1093 // Quads are clipped to the delegated renderer layer. 1094 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1095 1096 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1097 host_impl_->DidDrawAllLayers(frame); 1098} 1099 1100TEST_F(DelegatedRendererLayerImplTestClip, 1101 QuadsClipped_LayerClipped_NoSurface) { 1102 root_delegated_render_pass_is_clipped_ = true; 1103 clip_delegated_renderer_layer_ = true; 1104 SetUpTest(); 1105 1106 LayerTreeHostImpl::FrameData frame; 1107 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1108 1109 ASSERT_EQ(2u, frame.render_passes.size()); 1110 const QuadList& contrib_delegated_quad_list = 1111 frame.render_passes[0]->quad_list; 1112 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1113 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1114 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1115 const SharedQuadState* root_delegated_shared_quad_state = 1116 root_delegated_quad_list[0]->shared_quad_state; 1117 1118 // When the quads have a clip of their own, it is used, but it is 1119 // combined with the clip rect of the delegated renderer layer. 1120 EXPECT_EQ(gfx::Rect(25, 27, 19, 21).ToString(), 1121 root_delegated_shared_quad_state->clip_rect.ToString()); 1122 // Quads came with a clip rect. 1123 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1124 1125 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1126 host_impl_->DidDrawAllLayers(frame); 1127} 1128 1129TEST_F(DelegatedRendererLayerImplTestClip, 1130 QuadsUnclipped_LayerUnclipped_Surface) { 1131 root_delegated_render_pass_is_clipped_ = false; 1132 clip_delegated_renderer_layer_ = false; 1133 SetUpTest(); 1134 1135 delegated_renderer_layer_->SetForceRenderSurface(true); 1136 1137 LayerTreeHostImpl::FrameData frame; 1138 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1139 1140 ASSERT_EQ(3u, frame.render_passes.size()); 1141 const QuadList& contrib_delegated_quad_list = 1142 frame.render_passes[0]->quad_list; 1143 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1144 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1145 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1146 const SharedQuadState* root_delegated_shared_quad_state = 1147 root_delegated_quad_list[0]->shared_quad_state; 1148 1149 // When the layer owns a surface, the quads don't need to be clipped 1150 // further than they already specify. If they aren't clipped, then their 1151 // clip rect is ignored, and they are not set as clipped. 1152 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 1153 1154 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1155 host_impl_->DidDrawAllLayers(frame); 1156} 1157 1158TEST_F(DelegatedRendererLayerImplTestClip, 1159 QuadsClipped_LayerUnclipped_Surface) { 1160 root_delegated_render_pass_is_clipped_ = true; 1161 clip_delegated_renderer_layer_ = false; 1162 SetUpTest(); 1163 1164 delegated_renderer_layer_->SetForceRenderSurface(true); 1165 1166 LayerTreeHostImpl::FrameData frame; 1167 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1168 1169 ASSERT_EQ(3u, frame.render_passes.size()); 1170 const QuadList& contrib_delegated_quad_list = 1171 frame.render_passes[0]->quad_list; 1172 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1173 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1174 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1175 const SharedQuadState* root_delegated_shared_quad_state = 1176 root_delegated_quad_list[0]->shared_quad_state; 1177 1178 // When the quads have a clip of their own, it is used. 1179 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(), 1180 root_delegated_shared_quad_state->clip_rect.ToString()); 1181 // Quads came with a clip rect. 1182 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1183 1184 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1185 host_impl_->DidDrawAllLayers(frame); 1186} 1187 1188TEST_F(DelegatedRendererLayerImplTestClip, 1189 QuadsUnclipped_LayerClipped_Surface) { 1190 root_delegated_render_pass_is_clipped_ = false; 1191 clip_delegated_renderer_layer_ = true; 1192 SetUpTest(); 1193 1194 delegated_renderer_layer_->SetForceRenderSurface(true); 1195 1196 LayerTreeHostImpl::FrameData frame; 1197 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1198 1199 ASSERT_EQ(3u, frame.render_passes.size()); 1200 const QuadList& contrib_delegated_quad_list = 1201 frame.render_passes[0]->quad_list; 1202 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1203 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1204 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1205 const SharedQuadState* root_delegated_shared_quad_state = 1206 root_delegated_quad_list[0]->shared_quad_state; 1207 1208 // When the layer owns a surface, the quads don't need to be clipped 1209 // further than they already specify. If they aren't clipped, then their 1210 // clip rect is ignored, and they are not set as clipped. 1211 EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped); 1212 1213 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1214 host_impl_->DidDrawAllLayers(frame); 1215} 1216 1217TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) { 1218 root_delegated_render_pass_is_clipped_ = true; 1219 clip_delegated_renderer_layer_ = true; 1220 SetUpTest(); 1221 1222 delegated_renderer_layer_->SetForceRenderSurface(true); 1223 1224 LayerTreeHostImpl::FrameData frame; 1225 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1226 1227 ASSERT_EQ(3u, frame.render_passes.size()); 1228 const QuadList& contrib_delegated_quad_list = 1229 frame.render_passes[0]->quad_list; 1230 ASSERT_EQ(2u, contrib_delegated_quad_list.size()); 1231 const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list; 1232 ASSERT_EQ(5u, root_delegated_quad_list.size()); 1233 const SharedQuadState* root_delegated_shared_quad_state = 1234 root_delegated_quad_list[0]->shared_quad_state; 1235 1236 // When the quads have a clip of their own, it is used, but it is 1237 // combined with the clip rect of the delegated renderer layer. If the 1238 // layer owns a surface, then it does not have a clip rect of its own. 1239 EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(), 1240 root_delegated_shared_quad_state->clip_rect.ToString()); 1241 // Quads came with a clip rect. 1242 EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped); 1243 1244 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1245 host_impl_->DidDrawAllLayers(frame); 1246} 1247 1248TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) { 1249 scoped_ptr<LayerImpl> root_layer = LayerImpl::Create( 1250 host_impl_->active_tree(), 1).PassAs<LayerImpl>(); 1251 scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer = 1252 FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4); 1253 1254 host_impl_->SetViewportSize(gfx::Size(100, 100)); 1255 1256 delegated_renderer_layer->SetPosition(gfx::Point(3, 3)); 1257 delegated_renderer_layer->SetBounds(gfx::Size(10, 10)); 1258 delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10)); 1259 delegated_renderer_layer->SetDrawsContent(true); 1260 1261 ScopedPtrVector<RenderPass> delegated_render_passes; 1262 TestRenderPass* pass1 = AddRenderPass( 1263 &delegated_render_passes, 1264 RenderPass::Id(9, 6), 1265 gfx::Rect(0, 0, 10, 10), 1266 gfx::Transform()); 1267 AddQuad(pass1, gfx::Rect(0, 0, 6, 6), 33u); 1268 1269 // This render pass isn't part of the frame. 1270 scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create()); 1271 missing_pass->SetNew(RenderPass::Id(9, 7), 1272 gfx::Rect(7, 7, 7, 7), 1273 gfx::Rect(7, 7, 7, 7), 1274 gfx::Transform()); 1275 1276 // But a render pass quad refers to it. 1277 AddRenderPassQuad(pass1, missing_pass.get()); 1278 1279 delegated_renderer_layer->SetFrameDataForRenderPasses( 1280 &delegated_render_passes); 1281 1282 // The RenderPasses should be taken by the layer. 1283 EXPECT_EQ(0u, delegated_render_passes.size()); 1284 1285 root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>()); 1286 host_impl_->active_tree()->SetRootLayer(root_layer.Pass()); 1287 1288 LayerTreeHostImpl::FrameData frame; 1289 EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect())); 1290 1291 // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad. 1292 ASSERT_EQ(1u, frame.render_passes.size()); 1293 ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size()); 1294 EXPECT_EQ(DrawQuad::SOLID_COLOR, 1295 frame.render_passes[0]->quad_list[0]->material); 1296 1297 host_impl_->DrawLayers(&frame, base::TimeTicks::Now()); 1298 host_impl_->DidDrawAllLayers(frame); 1299} 1300 1301} // namespace 1302} // namespace cc 1303