1// Copyright 2013 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/trees/layer_tree_host.h" 6 7#include <algorithm> 8 9#include "base/bind.h" 10#include "base/location.h" 11#include "base/synchronization/waitable_event.h" 12#include "base/threading/thread.h" 13#include "base/time/time.h" 14#include "cc/layers/delegated_frame_provider.h" 15#include "cc/layers/delegated_frame_resource_collection.h" 16#include "cc/layers/delegated_renderer_layer.h" 17#include "cc/layers/delegated_renderer_layer_impl.h" 18#include "cc/output/compositor_frame.h" 19#include "cc/output/compositor_frame_ack.h" 20#include "cc/output/delegated_frame_data.h" 21#include "cc/quads/render_pass_draw_quad.h" 22#include "cc/quads/shared_quad_state.h" 23#include "cc/quads/texture_draw_quad.h" 24#include "cc/resources/returned_resource.h" 25#include "cc/test/fake_delegated_renderer_layer.h" 26#include "cc/test/fake_delegated_renderer_layer_impl.h" 27#include "cc/test/fake_output_surface.h" 28#include "cc/test/layer_tree_test.h" 29#include "cc/trees/layer_tree_impl.h" 30#include "gpu/GLES2/gl2extchromium.h" 31 32namespace cc { 33namespace { 34 35bool ReturnedResourceLower(const ReturnedResource& a, 36 const ReturnedResource& b) { 37 return a.id < b.id; 38} 39 40// Tests if the list of resources matches an expectation, modulo the order. 41bool ResourcesMatch(ReturnedResourceArray actual, 42 unsigned* expected, 43 size_t expected_count) { 44 std::sort(actual.begin(), actual.end(), ReturnedResourceLower); 45 std::sort(expected, expected + expected_count); 46 size_t actual_index = 0; 47 48 // for each element of the expected array, count off one of the actual array 49 // (after checking it matches). 50 for (size_t expected_index = 0; expected_index < expected_count; 51 ++expected_index) { 52 EXPECT_LT(actual_index, actual.size()); 53 if (actual_index >= actual.size()) 54 return false; 55 EXPECT_EQ(actual[actual_index].id, expected[expected_index]); 56 if (actual[actual_index].id != expected[expected_index]) 57 return false; 58 EXPECT_GT(actual[actual_index].count, 0); 59 if (actual[actual_index].count <= 0) { 60 return false; 61 } else { 62 --actual[actual_index].count; 63 if (actual[actual_index].count == 0) 64 ++actual_index; 65 } 66 } 67 EXPECT_EQ(actual_index, actual.size()); 68 return actual_index == actual.size(); 69} 70 71#define EXPECT_RESOURCES(expected, actual) \ 72 EXPECT_TRUE(ResourcesMatch(actual, expected, arraysize(expected))); 73 74// These tests deal with delegated renderer layers. 75class LayerTreeHostDelegatedTest : public LayerTreeTest { 76 protected: 77 scoped_ptr<DelegatedFrameData> CreateFrameData( 78 const gfx::Rect& root_output_rect, 79 const gfx::Rect& root_damage_rect) { 80 scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData); 81 82 scoped_ptr<RenderPass> root_pass(RenderPass::Create()); 83 root_pass->SetNew(RenderPassId(1, 1), 84 root_output_rect, 85 root_damage_rect, 86 gfx::Transform()); 87 frame->render_pass_list.push_back(root_pass.Pass()); 88 return frame.Pass(); 89 } 90 91 scoped_ptr<DelegatedFrameData> CreateInvalidFrameData( 92 const gfx::Rect& root_output_rect, 93 const gfx::Rect& root_damage_rect) { 94 scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData); 95 96 scoped_ptr<RenderPass> root_pass(RenderPass::Create()); 97 root_pass->SetNew(RenderPassId(1, 1), 98 root_output_rect, 99 root_damage_rect, 100 gfx::Transform()); 101 102 SharedQuadState* shared_quad_state = 103 root_pass->CreateAndAppendSharedQuadState(); 104 105 gfx::Rect rect = root_output_rect; 106 gfx::Rect opaque_rect = root_output_rect; 107 gfx::Rect visible_rect = root_output_rect; 108 // An invalid resource id! The resource isn't part of the frame. 109 unsigned resource_id = 5; 110 bool premultiplied_alpha = false; 111 gfx::PointF uv_top_left = gfx::PointF(0.f, 0.f); 112 gfx::PointF uv_bottom_right = gfx::PointF(1.f, 1.f); 113 SkColor background_color = 0; 114 float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f}; 115 bool flipped = false; 116 117 TextureDrawQuad* invalid_draw_quad = 118 root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); 119 invalid_draw_quad->SetNew(shared_quad_state, 120 rect, 121 opaque_rect, 122 visible_rect, 123 resource_id, 124 premultiplied_alpha, 125 uv_top_left, 126 uv_bottom_right, 127 background_color, 128 vertex_opacity, 129 flipped); 130 131 frame->render_pass_list.push_back(root_pass.Pass()); 132 return frame.Pass(); 133 } 134 135 void AddTransferableResource(DelegatedFrameData* frame, 136 ResourceProvider::ResourceId resource_id) { 137 TransferableResource resource; 138 resource.id = resource_id; 139 resource.mailbox_holder.texture_target = GL_TEXTURE_2D; 140 GLbyte arbitrary_mailbox[GL_MAILBOX_SIZE_CHROMIUM] = { 141 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 142 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 143 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4}; 144 resource.mailbox_holder.mailbox.SetName(arbitrary_mailbox); 145 frame->resource_list.push_back(resource); 146 } 147 148 void AddTextureQuad(DelegatedFrameData* frame, 149 ResourceProvider::ResourceId resource_id) { 150 RenderPass* render_pass = frame->render_pass_list[0]; 151 SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState(); 152 TextureDrawQuad* quad = 153 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); 154 float vertex_opacity[4] = { 1.f, 1.f, 1.f, 1.f }; 155 quad->SetNew(sqs, 156 gfx::Rect(0, 0, 10, 10), 157 gfx::Rect(0, 0, 10, 10), 158 gfx::Rect(0, 0, 10, 10), 159 resource_id, 160 false, 161 gfx::PointF(0.f, 0.f), 162 gfx::PointF(1.f, 1.f), 163 SK_ColorTRANSPARENT, 164 vertex_opacity, 165 false); 166 } 167 168 void AddRenderPass(DelegatedFrameData* frame, 169 RenderPassId id, 170 const gfx::Rect& output_rect, 171 const gfx::Rect& damage_rect, 172 const FilterOperations& filters, 173 const FilterOperations& background_filters) { 174 for (size_t i = 0; i < frame->render_pass_list.size(); ++i) 175 DCHECK(id != frame->render_pass_list[i]->id); 176 177 scoped_ptr<RenderPass> pass(RenderPass::Create()); 178 pass->SetNew(id, 179 output_rect, 180 damage_rect, 181 gfx::Transform()); 182 frame->render_pass_list.push_back(pass.Pass()); 183 184 RenderPass* render_pass = frame->render_pass_list[0]; 185 SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState(); 186 RenderPassDrawQuad* quad = 187 render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 188 189 quad->SetNew(sqs, 190 output_rect, 191 output_rect, 192 id, 193 0, // mask_resource_id 194 gfx::Rect(0, 0, 1, 1), // mask_uv_rect 195 filters, 196 gfx::Vector2dF(), 197 background_filters); 198 } 199 200 static ResourceProvider::ResourceId AppendResourceId( 201 std::vector<ResourceProvider::ResourceId>* resources_in_last_sent_frame, 202 ResourceProvider::ResourceId resource_id) { 203 resources_in_last_sent_frame->push_back(resource_id); 204 return resource_id; 205 } 206 207 void ReturnUnusedResourcesFromParent(LayerTreeHostImpl* host_impl) { 208 DelegatedFrameData* delegated_frame_data = 209 output_surface()->last_sent_frame().delegated_frame_data.get(); 210 if (!delegated_frame_data) 211 return; 212 213 std::vector<ResourceProvider::ResourceId> resources_in_last_sent_frame; 214 for (size_t i = 0; i < delegated_frame_data->resource_list.size(); ++i) { 215 resources_in_last_sent_frame.push_back( 216 delegated_frame_data->resource_list[i].id); 217 } 218 219 std::vector<ResourceProvider::ResourceId> resources_to_return; 220 221 const TransferableResourceArray& resources_held_by_parent = 222 output_surface()->resources_held_by_parent(); 223 for (size_t i = 0; i < resources_held_by_parent.size(); ++i) { 224 ResourceProvider::ResourceId resource_in_parent = 225 resources_held_by_parent[i].id; 226 bool resource_in_parent_is_not_part_of_frame = 227 std::find(resources_in_last_sent_frame.begin(), 228 resources_in_last_sent_frame.end(), 229 resource_in_parent) == resources_in_last_sent_frame.end(); 230 if (resource_in_parent_is_not_part_of_frame) 231 resources_to_return.push_back(resource_in_parent); 232 } 233 234 if (resources_to_return.empty()) 235 return; 236 237 CompositorFrameAck ack; 238 for (size_t i = 0; i < resources_to_return.size(); ++i) 239 output_surface()->ReturnResource(resources_to_return[i], &ack); 240 host_impl->ReclaimResources(&ack); 241 } 242}; 243 244class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer 245 : public LayerTreeHostDelegatedTest, 246 public DelegatedFrameResourceCollectionClient { 247 public: 248 LayerTreeHostDelegatedTestCaseSingleDelegatedLayer() 249 : resource_collection_(new DelegatedFrameResourceCollection), 250 available_(false) { 251 resource_collection_->SetClient(this); 252 } 253 254 virtual void SetupTree() OVERRIDE { 255 root_ = Layer::Create(); 256 root_->SetBounds(gfx::Size(15, 15)); 257 258 layer_tree_host()->SetRootLayer(root_); 259 LayerTreeHostDelegatedTest::SetupTree(); 260 } 261 262 virtual void BeginTest() OVERRIDE { 263 resource_collection_->SetClient(this); 264 PostSetNeedsCommitToMainThread(); 265 } 266 267 void SetFrameData(scoped_ptr<DelegatedFrameData> frame_data) { 268 RenderPass* root_pass = frame_data->render_pass_list.back(); 269 gfx::Size frame_size = root_pass->output_rect.size(); 270 271 if (frame_provider_.get() && frame_size == frame_provider_->frame_size()) { 272 frame_provider_->SetFrameData(frame_data.Pass()); 273 return; 274 } 275 276 if (delegated_.get()) { 277 delegated_->RemoveFromParent(); 278 delegated_ = NULL; 279 frame_provider_ = NULL; 280 } 281 282 frame_provider_ = new DelegatedFrameProvider(resource_collection_.get(), 283 frame_data.Pass()); 284 285 delegated_ = CreateDelegatedLayer(frame_provider_.get()); 286 } 287 288 scoped_refptr<DelegatedRendererLayer> CreateDelegatedLayer( 289 DelegatedFrameProvider* frame_provider) { 290 scoped_refptr<DelegatedRendererLayer> delegated = 291 FakeDelegatedRendererLayer::Create(frame_provider); 292 delegated->SetBounds(gfx::Size(10, 10)); 293 delegated->SetIsDrawable(true); 294 295 root_->AddChild(delegated); 296 return delegated; 297 } 298 299 virtual void AfterTest() OVERRIDE { resource_collection_->SetClient(NULL); } 300 301 // DelegatedFrameProviderClient implementation. 302 virtual void UnusedResourcesAreAvailable() OVERRIDE { available_ = true; } 303 304 bool TestAndResetAvailable() { 305 bool available = available_; 306 available_ = false; 307 return available; 308 } 309 310 protected: 311 scoped_refptr<DelegatedFrameResourceCollection> resource_collection_; 312 scoped_refptr<DelegatedFrameProvider> frame_provider_; 313 scoped_refptr<Layer> root_; 314 scoped_refptr<DelegatedRendererLayer> delegated_; 315 bool available_; 316}; 317 318class LayerTreeHostDelegatedTestCreateChildId 319 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 320 public: 321 LayerTreeHostDelegatedTestCreateChildId() 322 : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(), 323 num_activates_(0), 324 did_reset_child_id_(false) {} 325 326 virtual void DidCommit() OVERRIDE { 327 if (TestEnded()) 328 return; 329 SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1))); 330 } 331 332 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 333 if (host_impl->active_tree()->source_frame_number() < 1) 334 return; 335 336 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 337 FakeDelegatedRendererLayerImpl* delegated_impl = 338 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 339 340 TestContextProvider* context_provider = static_cast<TestContextProvider*>( 341 host_impl->output_surface()->context_provider()); 342 343 ++num_activates_; 344 switch (num_activates_) { 345 case 2: 346 EXPECT_TRUE(delegated_impl->ChildId()); 347 EXPECT_FALSE(did_reset_child_id_); 348 349 context_provider->ContextGL()->LoseContextCHROMIUM( 350 GL_GUILTY_CONTEXT_RESET_ARB, 351 GL_INNOCENT_CONTEXT_RESET_ARB); 352 context_provider->ContextGL()->Flush(); 353 break; 354 case 3: 355 EXPECT_TRUE(delegated_impl->ChildId()); 356 EXPECT_TRUE(did_reset_child_id_); 357 EndTest(); 358 break; 359 } 360 } 361 362 virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl, 363 bool success) OVERRIDE { 364 EXPECT_TRUE(success); 365 366 if (num_activates_ < 2) 367 return; 368 369 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 370 FakeDelegatedRendererLayerImpl* delegated_impl = 371 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 372 373 EXPECT_EQ(2, num_activates_); 374 EXPECT_FALSE(delegated_impl->ChildId()); 375 did_reset_child_id_ = true; 376 } 377 378 protected: 379 int num_activates_; 380 bool did_reset_child_id_; 381}; 382 383SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCreateChildId); 384 385// Test that we can gracefully handle invalid frames after the context was lost. 386// For example, we might be trying to use the previous frame in that case and 387// have to make sure we don't crash because our resource accounting goes wrong. 388class LayerTreeHostDelegatedTestInvalidFrameAfterContextLost 389 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 390 public: 391 LayerTreeHostDelegatedTestInvalidFrameAfterContextLost() 392 : num_activates_(0), num_output_surfaces_initialized_(0) {} 393 394 virtual void DidCommit() OVERRIDE { 395 if (TestEnded()) 396 return; 397 scoped_ptr<DelegatedFrameData> frame1 = 398 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 399 AddTextureQuad(frame1.get(), 999); 400 AddTransferableResource(frame1.get(), 999); 401 SetFrameData(frame1.Pass()); 402 } 403 404 virtual void DidInitializeOutputSurface() OVERRIDE { 405 if (!num_output_surfaces_initialized_++) 406 return; 407 408 scoped_refptr<DelegatedRendererLayer> old_delegated = delegated_; 409 SetFrameData( 410 CreateInvalidFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1))); 411 // Make sure we end up using the same layer, or we won't test the right 412 // thing, which is to make sure we can handle an invalid frame when using 413 // a stale layer from before the context was lost. 414 DCHECK(delegated_.get() == old_delegated.get()); 415 } 416 417 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 418 if (host_impl->active_tree()->source_frame_number() < 1) 419 return; 420 421 TestContextProvider* context_provider = static_cast<TestContextProvider*>( 422 host_impl->output_surface()->context_provider()); 423 424 ++num_activates_; 425 switch (num_activates_) { 426 case 2: 427 context_provider->ContextGL()->LoseContextCHROMIUM( 428 GL_GUILTY_CONTEXT_RESET_ARB, 429 GL_INNOCENT_CONTEXT_RESET_ARB); 430 break; 431 case 3: 432 EndTest(); 433 break; 434 } 435 } 436 437 virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl, 438 bool success) OVERRIDE { 439 EXPECT_TRUE(success); 440 441 if (num_activates_ < 2) 442 return; 443 444 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 445 FakeDelegatedRendererLayerImpl* delegated_impl = 446 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 447 448 EXPECT_EQ(2, num_activates_); 449 // Resources should have gotten cleared after the context was lost. 450 EXPECT_EQ(0U, delegated_impl->Resources().size()); 451 } 452 453 virtual void AfterTest() OVERRIDE { 454 LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::AfterTest(); 455 EXPECT_EQ(2, num_output_surfaces_initialized_); 456 } 457 458 protected: 459 int num_activates_; 460 int num_output_surfaces_initialized_; 461}; 462 463SINGLE_AND_MULTI_THREAD_TEST_F( 464 LayerTreeHostDelegatedTestInvalidFrameAfterContextLost); 465 466class LayerTreeHostDelegatedTestLayerUsesFrameDamage 467 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 468 public: 469 LayerTreeHostDelegatedTestLayerUsesFrameDamage() 470 : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(), 471 first_draw_for_source_frame_(true) {} 472 473 virtual void DidCommit() OVERRIDE { 474 int next_source_frame_number = layer_tree_host()->source_frame_number(); 475 switch (next_source_frame_number) { 476 case 1: 477 // The first time the layer gets a frame the whole layer should be 478 // damaged. 479 SetFrameData( 480 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1))); 481 break; 482 case 2: 483 // A different frame size will damage the whole layer. 484 SetFrameData( 485 CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(0, 0, 0, 0))); 486 break; 487 case 3: 488 // Should create a total amount of gfx::Rect(2, 2, 8, 6) damage: 489 // (2, 2, 10, 6) clamped to the root output rect. 490 SetFrameData( 491 CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(2, 2, 5, 5))); 492 SetFrameData( 493 CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(7, 2, 5, 6))); 494 break; 495 case 4: 496 // Should create zero damage. 497 layer_tree_host()->SetNeedsCommit(); 498 break; 499 case 5: 500 // Should damage the full viewport. 501 delegated_->SetBounds(gfx::Size(2, 2)); 502 break; 503 case 6: 504 // Should create zero damage. 505 layer_tree_host()->SetNeedsCommit(); 506 break; 507 case 7: 508 // Should damage the full layer, tho the frame size is not changing. 509 delegated_->SetBounds(gfx::Size(6, 6)); 510 SetFrameData( 511 CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(1, 1, 2, 2))); 512 break; 513 case 8: 514 // Should create zero damage. 515 layer_tree_host()->SetNeedsCommit(); 516 break; 517 case 9: 518 // Should create zero damage. 519 layer_tree_host()->SetNeedsCommit(); 520 break; 521 case 10: 522 // Changing the frame size damages the full layer. 523 SetFrameData( 524 CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(4, 4, 1, 1))); 525 break; 526 case 11: 527 // An invalid frame isn't used, so it should not cause damage. 528 SetFrameData(CreateInvalidFrameData(gfx::Rect(0, 0, 5, 5), 529 gfx::Rect(4, 4, 1, 1))); 530 break; 531 case 12: 532 // Should create gfx::Rect(1, 1, 2, 2) of damage. 533 SetFrameData( 534 CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(1, 1, 2, 2))); 535 break; 536 case 13: 537 // Should create zero damage. 538 layer_tree_host()->SetNeedsCommit(); 539 break; 540 case 14: 541 // Moving the layer out of the tree and back in will damage the whole 542 // impl layer. 543 delegated_->RemoveFromParent(); 544 layer_tree_host()->root_layer()->AddChild(delegated_); 545 break; 546 case 15: 547 // Make a larger frame with lots of damage. Then a frame smaller than 548 // the first frame's damage. The entire layer should be damaged, but 549 // nothing more. 550 SetFrameData( 551 CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10))); 552 SetFrameData( 553 CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(1, 1, 2, 2))); 554 break; 555 case 16: 556 // Make a frame with lots of damage. Then replace it with a frame with 557 // no damage. The entire layer should be damaged, but nothing more. 558 SetFrameData( 559 CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10))); 560 SetFrameData( 561 CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 0, 0))); 562 break; 563 case 17: 564 // Make another layer that uses the same frame provider. The new layer 565 // should be damaged. 566 delegated_copy_ = CreateDelegatedLayer(frame_provider_.get()); 567 delegated_copy_->SetPosition(gfx::Point(5, 0)); 568 569 // Also set a new frame. 570 SetFrameData( 571 CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(4, 0, 1, 1))); 572 break; 573 case 18: 574 // Set another new frame, both layers should be damaged in the same 575 // ways. 576 SetFrameData( 577 CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(3, 3, 1, 1))); 578 break; 579 } 580 first_draw_for_source_frame_ = true; 581 } 582 583 virtual DrawResult PrepareToDrawOnThread( 584 LayerTreeHostImpl* host_impl, 585 LayerTreeHostImpl::FrameData* frame, 586 DrawResult draw_result) OVERRIDE { 587 EXPECT_EQ(DRAW_SUCCESS, draw_result); 588 589 if (!first_draw_for_source_frame_) 590 return draw_result; 591 592 gfx::Rect damage_rect; 593 if (!frame->has_no_damage) { 594 damage_rect = frame->render_passes.back()->damage_rect; 595 } else { 596 // If there is no damage, then we have no render passes to send. 597 EXPECT_TRUE(frame->render_passes.empty()); 598 } 599 600 switch (host_impl->active_tree()->source_frame_number()) { 601 case 0: 602 // First frame is damaged because of viewport resize. 603 EXPECT_EQ(gfx::Rect(15, 15).ToString(), damage_rect.ToString()); 604 break; 605 case 1: 606 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 607 break; 608 case 2: 609 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 610 break; 611 case 3: 612 EXPECT_EQ(gfx::Rect(2, 2, 8, 6).ToString(), damage_rect.ToString()); 613 break; 614 case 4: 615 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 616 break; 617 case 5: 618 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 619 break; 620 case 6: 621 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 622 break; 623 case 7: 624 EXPECT_EQ(gfx::Rect(6, 6).ToString(), damage_rect.ToString()); 625 break; 626 case 8: 627 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 628 break; 629 case 9: 630 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 631 break; 632 case 10: 633 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 634 break; 635 case 11: 636 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 637 break; 638 case 12: 639 EXPECT_EQ(gfx::Rect(1, 1, 2, 2).ToString(), damage_rect.ToString()); 640 break; 641 case 13: 642 EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString()); 643 break; 644 case 14: 645 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 646 break; 647 case 15: 648 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 649 break; 650 case 16: 651 EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString()); 652 break; 653 case 17: 654 EXPECT_EQ(gfx::UnionRects(gfx::Rect(5, 0, 10, 10), 655 gfx::Rect(4, 0, 1, 1)).ToString(), 656 damage_rect.ToString()); 657 break; 658 case 18: 659 EXPECT_EQ(gfx::Rect(3, 3, 6, 1).ToString(), damage_rect.ToString()); 660 EndTest(); 661 break; 662 } 663 664 return draw_result; 665 } 666 667 protected: 668 scoped_refptr<DelegatedRendererLayer> delegated_copy_; 669 bool first_draw_for_source_frame_; 670}; 671 672SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestLayerUsesFrameDamage); 673 674class LayerTreeHostDelegatedTestMergeResources 675 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 676 public: 677 virtual void BeginTest() OVERRIDE { 678 // Push two frames to the delegated renderer layer with no commit between. 679 680 // The first frame has resource 999. 681 scoped_ptr<DelegatedFrameData> frame1 = 682 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 683 AddTextureQuad(frame1.get(), 999); 684 AddTransferableResource(frame1.get(), 999); 685 SetFrameData(frame1.Pass()); 686 687 // The second frame uses resource 999 still, but also adds 555. 688 scoped_ptr<DelegatedFrameData> frame2 = 689 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 690 AddTextureQuad(frame2.get(), 999); 691 AddTransferableResource(frame2.get(), 999); 692 AddTextureQuad(frame2.get(), 555); 693 AddTransferableResource(frame2.get(), 555); 694 SetFrameData(frame2.Pass()); 695 696 // The resource 999 from frame1 is returned since it is still on the main 697 // thread. 698 ReturnedResourceArray returned_resources; 699 resource_collection_->TakeUnusedResourcesForChildCompositor( 700 &returned_resources); 701 { 702 unsigned expected[] = {999}; 703 EXPECT_RESOURCES(expected, returned_resources); 704 EXPECT_TRUE(TestAndResetAvailable()); 705 } 706 707 PostSetNeedsCommitToMainThread(); 708 } 709 710 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 711 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 712 FakeDelegatedRendererLayerImpl* delegated_impl = 713 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 714 715 const ResourceProvider::ResourceIdMap& map = 716 host_impl->resource_provider()->GetChildToParentMap( 717 delegated_impl->ChildId()); 718 719 // Both frames' resources should be in the parent's resource provider. 720 EXPECT_EQ(2u, map.size()); 721 EXPECT_EQ(1u, map.count(999)); 722 EXPECT_EQ(1u, map.count(555)); 723 724 EXPECT_EQ(2u, delegated_impl->Resources().size()); 725 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 726 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 727 728 EndTest(); 729 } 730}; 731 732SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestMergeResources); 733 734class LayerTreeHostDelegatedTestRemapResourcesInQuads 735 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 736 public: 737 virtual void BeginTest() OVERRIDE { 738 // Generate a frame with two resources in it. 739 scoped_ptr<DelegatedFrameData> frame = 740 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 741 AddTextureQuad(frame.get(), 999); 742 AddTransferableResource(frame.get(), 999); 743 AddTextureQuad(frame.get(), 555); 744 AddTransferableResource(frame.get(), 555); 745 SetFrameData(frame.Pass()); 746 747 PostSetNeedsCommitToMainThread(); 748 } 749 750 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 751 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 752 FakeDelegatedRendererLayerImpl* delegated_impl = 753 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 754 755 const ResourceProvider::ResourceIdMap& map = 756 host_impl->resource_provider()->GetChildToParentMap( 757 delegated_impl->ChildId()); 758 759 // The frame's resource should be in the parent's resource provider. 760 EXPECT_EQ(2u, map.size()); 761 EXPECT_EQ(1u, map.count(999)); 762 EXPECT_EQ(1u, map.count(555)); 763 764 ResourceProvider::ResourceId parent_resource_id1 = map.find(999)->second; 765 EXPECT_NE(parent_resource_id1, 999u); 766 ResourceProvider::ResourceId parent_resource_id2 = map.find(555)->second; 767 EXPECT_NE(parent_resource_id2, 555u); 768 769 // The resources in the quads should be remapped to the parent's namespace. 770 const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast( 771 delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(0)); 772 EXPECT_EQ(parent_resource_id1, quad1->resource_id); 773 const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast( 774 delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(1)); 775 EXPECT_EQ(parent_resource_id2, quad2->resource_id); 776 777 EndTest(); 778 } 779}; 780 781SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemapResourcesInQuads); 782 783class LayerTreeHostDelegatedTestReturnUnusedResources 784 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 785 public: 786 virtual void BeginTest() OVERRIDE { 787 PostSetNeedsCommitToMainThread(); 788 } 789 790 virtual void DidCommitAndDrawFrame() OVERRIDE { 791 scoped_ptr<DelegatedFrameData> frame; 792 ReturnedResourceArray resources; 793 794 int next_source_frame_number = layer_tree_host()->source_frame_number(); 795 switch (next_source_frame_number) { 796 case 1: 797 // Generate a frame with two resources in it. 798 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 799 AddTextureQuad(frame.get(), 999); 800 AddTransferableResource(frame.get(), 999); 801 AddTextureQuad(frame.get(), 555); 802 AddTransferableResource(frame.get(), 555); 803 SetFrameData(frame.Pass()); 804 break; 805 case 2: 806 // All of the resources are in use. 807 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 808 EXPECT_EQ(0u, resources.size()); 809 EXPECT_FALSE(TestAndResetAvailable()); 810 811 // Keep using 999 but stop using 555. 812 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 813 AddTextureQuad(frame.get(), 999); 814 AddTransferableResource(frame.get(), 999); 815 AddTextureQuad(frame.get(), 444); 816 AddTransferableResource(frame.get(), 444); 817 SetFrameData(frame.Pass()); 818 break; 819 case 3: 820 // 555 is no longer in use. 821 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 822 { 823 unsigned expected[] = {555}; 824 EXPECT_RESOURCES(expected, resources); 825 EXPECT_TRUE(TestAndResetAvailable()); 826 } 827 828 // Stop using any resources. 829 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 830 SetFrameData(frame.Pass()); 831 break; 832 case 4: 833 // Postpone collecting resources for a frame. They should still be there 834 // the next frame. 835 layer_tree_host()->SetNeedsCommit(); 836 return; 837 case 5: 838 // 444 and 999 are no longer in use. We sent two refs to 999, so we 839 // should get two back. 840 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 841 { 842 unsigned expected[] = {444, 999, 999}; 843 EXPECT_RESOURCES(expected, resources); 844 EXPECT_TRUE(TestAndResetAvailable()); 845 } 846 EndTest(); 847 break; 848 } 849 850 // Resources are never immediately released. 851 ReturnedResourceArray empty_resources; 852 resource_collection_->TakeUnusedResourcesForChildCompositor( 853 &empty_resources); 854 EXPECT_EQ(0u, empty_resources.size()); 855 EXPECT_FALSE(TestAndResetAvailable()); 856 } 857 858 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 859 bool result) OVERRIDE { 860 ReturnUnusedResourcesFromParent(host_impl); 861 } 862}; 863 864SINGLE_AND_MULTI_THREAD_TEST_F( 865 LayerTreeHostDelegatedTestReturnUnusedResources); 866 867class LayerTreeHostDelegatedTestReusedResources 868 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 869 public: 870 virtual void BeginTest() OVERRIDE { 871 PostSetNeedsCommitToMainThread(); 872 } 873 874 virtual void DidCommitAndDrawFrame() OVERRIDE { 875 scoped_ptr<DelegatedFrameData> frame; 876 ReturnedResourceArray resources; 877 878 int next_source_frame_number = layer_tree_host()->source_frame_number(); 879 switch (next_source_frame_number) { 880 case 1: 881 // Generate a frame with some resources in it. 882 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 883 AddTextureQuad(frame.get(), 999); 884 AddTransferableResource(frame.get(), 999); 885 AddTextureQuad(frame.get(), 555); 886 AddTransferableResource(frame.get(), 555); 887 AddTextureQuad(frame.get(), 444); 888 AddTransferableResource(frame.get(), 444); 889 SetFrameData(frame.Pass()); 890 break; 891 case 2: 892 // All of the resources are in use. 893 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 894 EXPECT_EQ(0u, resources.size()); 895 EXPECT_FALSE(TestAndResetAvailable()); 896 897 // Keep using 999 but stop using 555 and 444. 898 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 899 AddTextureQuad(frame.get(), 999); 900 AddTransferableResource(frame.get(), 999); 901 SetFrameData(frame.Pass()); 902 903 // Resource are not immediately released. 904 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 905 EXPECT_EQ(0u, resources.size()); 906 EXPECT_FALSE(TestAndResetAvailable()); 907 908 // Now using 555 and 444 again, but not 999. 909 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 910 AddTextureQuad(frame.get(), 555); 911 AddTransferableResource(frame.get(), 555); 912 AddTextureQuad(frame.get(), 444); 913 AddTransferableResource(frame.get(), 444); 914 SetFrameData(frame.Pass()); 915 break; 916 case 3: 917 // The 999 resource is the only unused one. Two references were sent, so 918 // two should be returned. 919 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 920 { 921 unsigned expected[] = {999, 999}; 922 EXPECT_RESOURCES(expected, resources); 923 EXPECT_TRUE(TestAndResetAvailable()); 924 } 925 EndTest(); 926 break; 927 } 928 } 929 930 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 931 bool result) OVERRIDE { 932 ReturnUnusedResourcesFromParent(host_impl); 933 } 934}; 935 936SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestReusedResources); 937 938class LayerTreeHostDelegatedTestFrameBeforeAck 939 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 940 public: 941 virtual void BeginTest() OVERRIDE { 942 PostSetNeedsCommitToMainThread(); 943 } 944 945 virtual void DidCommitAndDrawFrame() OVERRIDE { 946 scoped_ptr<DelegatedFrameData> frame; 947 ReturnedResourceArray resources; 948 949 int next_source_frame_number = layer_tree_host()->source_frame_number(); 950 switch (next_source_frame_number) { 951 case 1: 952 // Generate a frame with some resources in it. 953 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 954 AddTextureQuad(frame.get(), 999); 955 AddTransferableResource(frame.get(), 999); 956 AddTextureQuad(frame.get(), 555); 957 AddTransferableResource(frame.get(), 555); 958 AddTextureQuad(frame.get(), 444); 959 AddTransferableResource(frame.get(), 444); 960 SetFrameData(frame.Pass()); 961 break; 962 case 2: 963 // All of the resources are in use. 964 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 965 EXPECT_EQ(0u, resources.size()); 966 EXPECT_FALSE(TestAndResetAvailable()); 967 968 // Keep using 999 but stop using 555 and 444. 969 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 970 AddTextureQuad(frame.get(), 999); 971 AddTransferableResource(frame.get(), 999); 972 SetFrameData(frame.Pass()); 973 974 // Resource are not immediately released. 975 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 976 EXPECT_EQ(0u, resources.size()); 977 EXPECT_FALSE(TestAndResetAvailable()); 978 979 // The parent compositor (this one) does a commit. 980 break; 981 case 3: 982 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 983 { 984 unsigned expected[] = {444, 555}; 985 EXPECT_RESOURCES(expected, resources); 986 EXPECT_TRUE(TestAndResetAvailable()); 987 } 988 989 // The child compositor sends a frame referring to resources not in the 990 // frame. 991 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 992 AddTextureQuad(frame.get(), 999); 993 AddTextureQuad(frame.get(), 555); 994 AddTextureQuad(frame.get(), 444); 995 SetFrameData(frame.Pass()); 996 break; 997 } 998 } 999 1000 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1001 if (host_impl->active_tree()->source_frame_number() != 3) 1002 return; 1003 1004 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1005 FakeDelegatedRendererLayerImpl* delegated_impl = 1006 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1007 1008 const ResourceProvider::ResourceIdMap& map = 1009 host_impl->resource_provider()->GetChildToParentMap( 1010 delegated_impl->ChildId()); 1011 1012 // The bad frame should be dropped. So we should only have one quad (the 1013 // one with resource 999) on the impl tree. And only 999 will be present 1014 // in the parent's resource provider. 1015 EXPECT_EQ(1u, map.size()); 1016 EXPECT_EQ(1u, map.count(999)); 1017 1018 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1019 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1020 1021 const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0]; 1022 EXPECT_EQ(1u, pass->quad_list.size()); 1023 const TextureDrawQuad* quad = 1024 TextureDrawQuad::MaterialCast(pass->quad_list.front()); 1025 EXPECT_EQ(map.find(999)->second, quad->resource_id); 1026 1027 EndTest(); 1028 } 1029 1030 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1031 bool result) OVERRIDE { 1032 ReturnUnusedResourcesFromParent(host_impl); 1033 } 1034}; 1035 1036SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestFrameBeforeAck); 1037 1038class LayerTreeHostDelegatedTestFrameBeforeTakeResources 1039 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1040 public: 1041 virtual void BeginTest() OVERRIDE { 1042 PostSetNeedsCommitToMainThread(); 1043 } 1044 1045 virtual void DidCommitAndDrawFrame() OVERRIDE { 1046 scoped_ptr<DelegatedFrameData> frame; 1047 ReturnedResourceArray resources; 1048 1049 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1050 switch (next_source_frame_number) { 1051 case 1: 1052 // Generate a frame with some resources in it. 1053 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1054 AddTextureQuad(frame.get(), 999); 1055 AddTransferableResource(frame.get(), 999); 1056 AddTextureQuad(frame.get(), 555); 1057 AddTransferableResource(frame.get(), 555); 1058 AddTextureQuad(frame.get(), 444); 1059 AddTransferableResource(frame.get(), 444); 1060 SetFrameData(frame.Pass()); 1061 break; 1062 case 2: 1063 // All of the resources are in use. 1064 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1065 EXPECT_EQ(0u, resources.size()); 1066 EXPECT_FALSE(TestAndResetAvailable()); 1067 1068 // Keep using 999 but stop using 555 and 444. 1069 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1070 AddTextureQuad(frame.get(), 999); 1071 AddTransferableResource(frame.get(), 999); 1072 SetFrameData(frame.Pass()); 1073 1074 // Resource are not immediately released. 1075 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1076 EXPECT_EQ(0u, resources.size()); 1077 EXPECT_FALSE(TestAndResetAvailable()); 1078 1079 // The parent compositor (this one) does a commit. 1080 break; 1081 case 3: 1082 // The child compositor sends a frame before taking resources back 1083 // from the previous commit. This frame makes use of the resources 555 1084 // and 444, which were just released during commit. 1085 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1086 AddTextureQuad(frame.get(), 999); 1087 AddTransferableResource(frame.get(), 999); 1088 AddTextureQuad(frame.get(), 555); 1089 AddTransferableResource(frame.get(), 555); 1090 AddTextureQuad(frame.get(), 444); 1091 AddTransferableResource(frame.get(), 444); 1092 SetFrameData(frame.Pass()); 1093 1094 // The resources are used by the new frame but are returned anyway since 1095 // we passed them again. 1096 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1097 { 1098 unsigned expected[] = {444, 555}; 1099 EXPECT_RESOURCES(expected, resources); 1100 EXPECT_TRUE(TestAndResetAvailable()); 1101 } 1102 break; 1103 case 4: 1104 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1105 EXPECT_EQ(0u, resources.size()); 1106 EXPECT_FALSE(TestAndResetAvailable()); 1107 EndTest(); 1108 break; 1109 } 1110 } 1111 1112 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1113 if (host_impl->active_tree()->source_frame_number() != 3) 1114 return; 1115 1116 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1117 FakeDelegatedRendererLayerImpl* delegated_impl = 1118 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1119 1120 const ResourceProvider::ResourceIdMap& map = 1121 host_impl->resource_provider()->GetChildToParentMap( 1122 delegated_impl->ChildId()); 1123 1124 // The third frame has all of the resources in it again, the delegated 1125 // renderer layer should continue to own the resources for it. 1126 EXPECT_EQ(3u, map.size()); 1127 EXPECT_EQ(1u, map.count(999)); 1128 EXPECT_EQ(1u, map.count(555)); 1129 EXPECT_EQ(1u, map.count(444)); 1130 1131 EXPECT_EQ(3u, delegated_impl->Resources().size()); 1132 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1133 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1134 EXPECT_EQ(1u, delegated_impl->Resources().count(444)); 1135 1136 const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0]; 1137 EXPECT_EQ(3u, pass->quad_list.size()); 1138 const TextureDrawQuad* quad1 = 1139 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0)); 1140 EXPECT_EQ(map.find(999)->second, quad1->resource_id); 1141 const TextureDrawQuad* quad2 = 1142 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1)); 1143 EXPECT_EQ(map.find(555)->second, quad2->resource_id); 1144 const TextureDrawQuad* quad3 = 1145 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(2)); 1146 EXPECT_EQ(map.find(444)->second, quad3->resource_id); 1147 } 1148 1149 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1150 bool result) OVERRIDE { 1151 ReturnUnusedResourcesFromParent(host_impl); 1152 } 1153}; 1154 1155SINGLE_AND_MULTI_THREAD_TEST_F( 1156 LayerTreeHostDelegatedTestFrameBeforeTakeResources); 1157 1158class LayerTreeHostDelegatedTestBadFrame 1159 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1160 public: 1161 virtual void BeginTest() OVERRIDE { 1162 PostSetNeedsCommitToMainThread(); 1163 } 1164 1165 virtual void DidCommitAndDrawFrame() OVERRIDE { 1166 scoped_ptr<DelegatedFrameData> frame; 1167 ReturnedResourceArray resources; 1168 1169 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1170 switch (next_source_frame_number) { 1171 case 1: 1172 // Generate a frame with some resources in it. 1173 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1174 AddTextureQuad(frame.get(), 999); 1175 AddTransferableResource(frame.get(), 999); 1176 AddTextureQuad(frame.get(), 555); 1177 AddTransferableResource(frame.get(), 555); 1178 SetFrameData(frame.Pass()); 1179 break; 1180 case 2: 1181 // All of the resources are in use. 1182 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1183 EXPECT_EQ(0u, resources.size()); 1184 EXPECT_FALSE(TestAndResetAvailable()); 1185 1186 // Generate a bad frame with a resource the layer doesn't have. The 1187 // 885 and 775 resources are unknown, while ownership of the legit 444 1188 // resource is passed in here. The bad frame does not use any of the 1189 // previous resources, 999 or 555. 1190 // A bad quad is present both before and after the good quad. 1191 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1192 AddTextureQuad(frame.get(), 885); 1193 AddTextureQuad(frame.get(), 444); 1194 AddTransferableResource(frame.get(), 444); 1195 AddTextureQuad(frame.get(), 775); 1196 SetFrameData(frame.Pass()); 1197 1198 // The parent compositor (this one) does a commit. 1199 break; 1200 case 3: 1201 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1202 EXPECT_EQ(0u, resources.size()); 1203 EXPECT_FALSE(TestAndResetAvailable()); 1204 1205 // Now send a good frame with 999 again. 1206 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1207 AddTextureQuad(frame.get(), 999); 1208 SetFrameData(frame.Pass()); 1209 1210 // The bad frame's resource is given back to the child compositor. 1211 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1212 { 1213 unsigned expected[] = {444}; 1214 EXPECT_RESOURCES(expected, resources); 1215 EXPECT_TRUE(TestAndResetAvailable()); 1216 } 1217 break; 1218 case 4: 1219 // The unused 555 from the last good frame is now released. 1220 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1221 { 1222 unsigned expected[] = {555}; 1223 EXPECT_RESOURCES(expected, resources); 1224 EXPECT_TRUE(TestAndResetAvailable()); 1225 } 1226 1227 EndTest(); 1228 break; 1229 } 1230 } 1231 1232 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1233 bool result) OVERRIDE { 1234 if (host_impl->active_tree()->source_frame_number() < 1) 1235 return; 1236 1237 ReturnUnusedResourcesFromParent(host_impl); 1238 1239 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1240 FakeDelegatedRendererLayerImpl* delegated_impl = 1241 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1242 1243 const ResourceProvider::ResourceIdMap& map = 1244 host_impl->resource_provider()->GetChildToParentMap( 1245 delegated_impl->ChildId()); 1246 1247 switch (host_impl->active_tree()->source_frame_number()) { 1248 case 1: { 1249 // We have the first good frame with just 990 and 555 in it. 1250 // layer. 1251 EXPECT_EQ(2u, map.size()); 1252 EXPECT_EQ(1u, map.count(999)); 1253 EXPECT_EQ(1u, map.count(555)); 1254 1255 EXPECT_EQ(2u, delegated_impl->Resources().size()); 1256 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1257 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1258 1259 const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0]; 1260 EXPECT_EQ(2u, pass->quad_list.size()); 1261 const TextureDrawQuad* quad1 = 1262 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0)); 1263 EXPECT_EQ(map.find(999)->second, quad1->resource_id); 1264 const TextureDrawQuad* quad2 = 1265 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1)); 1266 EXPECT_EQ(map.find(555)->second, quad2->resource_id); 1267 break; 1268 } 1269 case 2: { 1270 // We only keep resources from the last valid frame. 1271 EXPECT_EQ(2u, map.size()); 1272 EXPECT_EQ(1u, map.count(999)); 1273 EXPECT_EQ(1u, map.count(555)); 1274 1275 EXPECT_EQ(2u, delegated_impl->Resources().size()); 1276 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1277 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1278 1279 // The bad frame is dropped though, we still have the frame with 999 and 1280 // 555 in it. 1281 const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0]; 1282 EXPECT_EQ(2u, pass->quad_list.size()); 1283 const TextureDrawQuad* quad1 = 1284 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0)); 1285 EXPECT_EQ(map.find(999)->second, quad1->resource_id); 1286 const TextureDrawQuad* quad2 = 1287 TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1)); 1288 EXPECT_EQ(map.find(555)->second, quad2->resource_id); 1289 break; 1290 } 1291 case 3: { 1292 // We have the new good frame with just 999 in it. 1293 EXPECT_EQ(1u, map.size()); 1294 EXPECT_EQ(1u, map.count(999)); 1295 1296 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1297 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1298 1299 const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0]; 1300 EXPECT_EQ(1u, pass->quad_list.size()); 1301 const TextureDrawQuad* quad1 = 1302 TextureDrawQuad::MaterialCast(pass->quad_list.front()); 1303 EXPECT_EQ(map.find(999)->second, quad1->resource_id); 1304 break; 1305 } 1306 } 1307 } 1308}; 1309 1310SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestBadFrame); 1311 1312class LayerTreeHostDelegatedTestUnnamedResource 1313 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1314 public: 1315 virtual void BeginTest() OVERRIDE { 1316 PostSetNeedsCommitToMainThread(); 1317 } 1318 1319 virtual void DidCommit() OVERRIDE { 1320 scoped_ptr<DelegatedFrameData> frame; 1321 ReturnedResourceArray resources; 1322 1323 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1324 switch (next_source_frame_number) { 1325 case 1: 1326 // This frame includes two resources in it, but only uses one. 1327 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1328 AddTransferableResource(frame.get(), 999); 1329 AddTextureQuad(frame.get(), 555); 1330 AddTransferableResource(frame.get(), 555); 1331 SetFrameData(frame.Pass()); 1332 break; 1333 case 2: 1334 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1335 EXPECT_EQ(0u, resources.size()); 1336 EXPECT_FALSE(TestAndResetAvailable()); 1337 1338 // Now send an empty frame. 1339 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1340 SetFrameData(frame.Pass()); 1341 1342 // The unused resource should be returned. 1343 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1344 { 1345 unsigned expected[] = {999}; 1346 EXPECT_RESOURCES(expected, resources); 1347 EXPECT_TRUE(TestAndResetAvailable()); 1348 } 1349 1350 EndTest(); 1351 break; 1352 } 1353 } 1354 1355 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1356 if (host_impl->active_tree()->source_frame_number() != 1) 1357 return; 1358 1359 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1360 FakeDelegatedRendererLayerImpl* delegated_impl = 1361 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1362 1363 const ResourceProvider::ResourceIdMap& map = 1364 host_impl->resource_provider()->GetChildToParentMap( 1365 delegated_impl->ChildId()); 1366 1367 // The layer only held on to the resource that was used. 1368 EXPECT_EQ(1u, map.size()); 1369 EXPECT_EQ(1u, map.count(555)); 1370 1371 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1372 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1373 } 1374}; 1375 1376SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestUnnamedResource); 1377 1378class LayerTreeHostDelegatedTestDontLeakResource 1379 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1380 public: 1381 virtual void BeginTest() OVERRIDE { 1382 PostSetNeedsCommitToMainThread(); 1383 } 1384 1385 virtual void DidCommitAndDrawFrame() OVERRIDE { 1386 scoped_ptr<DelegatedFrameData> frame; 1387 ReturnedResourceArray resources; 1388 1389 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1390 switch (next_source_frame_number) { 1391 case 1: 1392 // This frame includes two resources in it. 1393 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1394 AddTextureQuad(frame.get(), 999); 1395 AddTransferableResource(frame.get(), 999); 1396 AddTextureQuad(frame.get(), 555); 1397 AddTransferableResource(frame.get(), 555); 1398 SetFrameData(frame.Pass()); 1399 1400 // But then we immediately stop using 999. 1401 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1402 AddTextureQuad(frame.get(), 555); 1403 AddTransferableResource(frame.get(), 555); 1404 SetFrameData(frame.Pass()); 1405 break; 1406 case 2: 1407 // The unused resources should be returned. 555 is still used, but it's 1408 // returned once to account for the first frame. 1409 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1410 { 1411 unsigned expected[] = {555, 999}; 1412 EXPECT_RESOURCES(expected, resources); 1413 EXPECT_TRUE(TestAndResetAvailable()); 1414 } 1415 // Send a frame with no resources in it. 1416 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1417 SetFrameData(frame.Pass()); 1418 break; 1419 case 3: 1420 // The now unused resource 555 should be returned. 1421 resources.clear(); 1422 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1423 { 1424 unsigned expected[] = {555}; 1425 EXPECT_RESOURCES(expected, resources); 1426 EXPECT_TRUE(TestAndResetAvailable()); 1427 } 1428 EndTest(); 1429 break; 1430 } 1431 } 1432 1433 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1434 if (host_impl->active_tree()->source_frame_number() != 1) 1435 return; 1436 1437 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1438 FakeDelegatedRendererLayerImpl* delegated_impl = 1439 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1440 1441 const ResourceProvider::ResourceIdMap& map = 1442 host_impl->resource_provider()->GetChildToParentMap( 1443 delegated_impl->ChildId()); 1444 1445 // The layer only held on to the resource that was used. 1446 EXPECT_EQ(1u, map.size()); 1447 EXPECT_EQ(1u, map.count(555)); 1448 1449 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1450 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1451 } 1452 1453 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1454 bool result) OVERRIDE { 1455 ReturnUnusedResourcesFromParent(host_impl); 1456 } 1457}; 1458 1459SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestDontLeakResource); 1460 1461class LayerTreeHostDelegatedTestResourceSentToParent 1462 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1463 public: 1464 virtual void DidCommitAndDrawFrame() OVERRIDE { 1465 scoped_ptr<DelegatedFrameData> frame; 1466 ReturnedResourceArray resources; 1467 1468 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1469 switch (next_source_frame_number) { 1470 case 1: 1471 // This frame includes two resources in it. 1472 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1473 AddTextureQuad(frame.get(), 999); 1474 AddTransferableResource(frame.get(), 999); 1475 AddTextureQuad(frame.get(), 555); 1476 AddTransferableResource(frame.get(), 555); 1477 SetFrameData(frame.Pass()); 1478 break; 1479 case 2: 1480 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1481 EXPECT_EQ(0u, resources.size()); 1482 EXPECT_FALSE(TestAndResetAvailable()); 1483 1484 // 999 is in use in the grandparent compositor, generate a frame without 1485 // it present. 1486 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1487 AddTextureQuad(frame.get(), 555); 1488 AddTransferableResource(frame.get(), 555); 1489 SetFrameData(frame.Pass()); 1490 break; 1491 case 3: 1492 // Since 999 is in the grandparent it is not returned. 1493 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1494 EXPECT_EQ(0u, resources.size()); 1495 EXPECT_FALSE(TestAndResetAvailable()); 1496 1497 // The impl side will get back the resource at some point. 1498 ImplThreadTaskRunner()->PostTask(FROM_HERE, 1499 receive_resource_on_thread_); 1500 break; 1501 } 1502 } 1503 1504 void ReceiveResourceOnThread(LayerTreeHostImpl* host_impl) { 1505 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1506 FakeDelegatedRendererLayerImpl* delegated_impl = 1507 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1508 1509 const ResourceProvider::ResourceIdMap& map = 1510 host_impl->resource_provider()->GetChildToParentMap( 1511 delegated_impl->ChildId()); 1512 1513 // Receive 999 back from the grandparent. 1514 CompositorFrameAck ack; 1515 output_surface()->ReturnResource(map.find(999)->second, &ack); 1516 host_impl->ReclaimResources(&ack); 1517 } 1518 1519 virtual void UnusedResourcesAreAvailable() OVERRIDE { 1520 EXPECT_EQ(3, layer_tree_host()->source_frame_number()); 1521 1522 ReturnedResourceArray resources; 1523 1524 // 999 was returned from the grandparent and could be released. 1525 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1526 { 1527 unsigned expected[] = {999}; 1528 EXPECT_RESOURCES(expected, resources); 1529 } 1530 1531 EndTest(); 1532 } 1533 1534 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1535 if (host_impl->active_tree()->source_frame_number() < 1) 1536 return; 1537 1538 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1539 FakeDelegatedRendererLayerImpl* delegated_impl = 1540 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1541 1542 const ResourceProvider::ResourceIdMap& map = 1543 host_impl->resource_provider()->GetChildToParentMap( 1544 delegated_impl->ChildId()); 1545 1546 switch (host_impl->active_tree()->source_frame_number()) { 1547 case 1: { 1548 EXPECT_EQ(2u, map.size()); 1549 EXPECT_EQ(1u, map.count(999)); 1550 EXPECT_EQ(1u, map.count(555)); 1551 1552 EXPECT_EQ(2u, delegated_impl->Resources().size()); 1553 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1554 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1555 1556 // The 999 resource will be sent to a grandparent compositor. 1557 break; 1558 } 1559 case 2: { 1560 EXPECT_EQ(2u, map.size()); 1561 EXPECT_EQ(1u, map.count(999)); 1562 EXPECT_EQ(1u, map.count(555)); 1563 1564 // 999 is in the parent, so not held by delegated renderer layer. 1565 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1566 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1567 1568 receive_resource_on_thread_ = 1569 base::Bind(&LayerTreeHostDelegatedTestResourceSentToParent:: 1570 ReceiveResourceOnThread, 1571 base::Unretained(this), 1572 host_impl); 1573 break; 1574 } 1575 case 3: 1576 // 999 should be released. 1577 EXPECT_EQ(1u, map.size()); 1578 EXPECT_EQ(1u, map.count(555)); 1579 1580 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1581 EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second)); 1582 break; 1583 } 1584 } 1585 1586 base::Closure receive_resource_on_thread_; 1587}; 1588 1589SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F( 1590 LayerTreeHostDelegatedTestResourceSentToParent); 1591 1592class LayerTreeHostDelegatedTestCommitWithoutTake 1593 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1594 public: 1595 virtual void BeginTest() OVERRIDE { 1596 // Prevent drawing with resources that are sent to the grandparent. 1597 layer_tree_host()->SetViewportSize(gfx::Size()); 1598 PostSetNeedsCommitToMainThread(); 1599 } 1600 1601 virtual void DidCommit() OVERRIDE { 1602 scoped_ptr<DelegatedFrameData> frame; 1603 ReturnedResourceArray resources; 1604 1605 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1606 switch (next_source_frame_number) { 1607 case 1: 1608 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1609 AddTextureQuad(frame.get(), 999); 1610 AddTransferableResource(frame.get(), 999); 1611 AddTextureQuad(frame.get(), 555); 1612 AddTransferableResource(frame.get(), 555); 1613 AddTextureQuad(frame.get(), 444); 1614 AddTransferableResource(frame.get(), 444); 1615 SetFrameData(frame.Pass()); 1616 break; 1617 case 2: 1618 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1619 EXPECT_EQ(0u, resources.size()); 1620 EXPECT_FALSE(TestAndResetAvailable()); 1621 1622 // Stop using 999 and 444 in this frame and commit. 1623 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1624 AddTextureQuad(frame.get(), 555); 1625 AddTransferableResource(frame.get(), 555); 1626 SetFrameData(frame.Pass()); 1627 // 999 and 444 will be returned for frame 1, but not 555 since it's in 1628 // the current frame. 1629 break; 1630 case 3: 1631 // Don't take resources here, but set a new frame that uses 999 again. 1632 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1633 AddTextureQuad(frame.get(), 999); 1634 AddTransferableResource(frame.get(), 999); 1635 AddTextureQuad(frame.get(), 555); 1636 AddTransferableResource(frame.get(), 555); 1637 SetFrameData(frame.Pass()); 1638 break; 1639 case 4: 1640 // 555 from frame 1 and 2 isn't returned since it's still in use. 999 1641 // from frame 1 is returned though. 1642 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1643 { 1644 unsigned expected[] = {444, 999}; 1645 EXPECT_RESOURCES(expected, resources); 1646 EXPECT_TRUE(TestAndResetAvailable()); 1647 } 1648 1649 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1650 SetFrameData(frame.Pass()); 1651 // 555 will be returned 3 times for frames 1 2 and 3, and 999 will be 1652 // returned once for frame 3. 1653 break; 1654 case 5: 1655 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1656 { 1657 unsigned expected[] = {555, 555, 555, 999}; 1658 EXPECT_RESOURCES(expected, resources); 1659 EXPECT_TRUE(TestAndResetAvailable()); 1660 } 1661 1662 EndTest(); 1663 break; 1664 } 1665 } 1666 1667 virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1668 if (host_impl->active_tree()->source_frame_number() < 1) 1669 return; 1670 1671 LayerImpl* root_impl = host_impl->active_tree()->root_layer(); 1672 FakeDelegatedRendererLayerImpl* delegated_impl = 1673 static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]); 1674 1675 const ResourceProvider::ResourceIdMap& map = 1676 host_impl->resource_provider()->GetChildToParentMap( 1677 delegated_impl->ChildId()); 1678 1679 switch (host_impl->active_tree()->source_frame_number()) { 1680 case 1: 1681 EXPECT_EQ(3u, map.size()); 1682 EXPECT_EQ(1u, map.count(999)); 1683 EXPECT_EQ(1u, map.count(555)); 1684 EXPECT_EQ(1u, map.count(444)); 1685 1686 EXPECT_EQ(3u, delegated_impl->Resources().size()); 1687 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1688 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1689 EXPECT_EQ(1u, delegated_impl->Resources().count(444)); 1690 break; 1691 case 2: 1692 EXPECT_EQ(1u, map.size()); 1693 EXPECT_EQ(1u, map.count(555)); 1694 1695 EXPECT_EQ(1u, delegated_impl->Resources().size()); 1696 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1697 break; 1698 case 3: 1699 EXPECT_EQ(2u, map.size()); 1700 EXPECT_EQ(1u, map.count(999)); 1701 EXPECT_EQ(1u, map.count(555)); 1702 1703 EXPECT_EQ(2u, delegated_impl->Resources().size()); 1704 EXPECT_EQ(1u, delegated_impl->Resources().count(999)); 1705 EXPECT_EQ(1u, delegated_impl->Resources().count(555)); 1706 } 1707 } 1708}; 1709 1710SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake); 1711 1712class DelegatedFrameIsActivatedDuringCommit 1713 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1714 protected: 1715 DelegatedFrameIsActivatedDuringCommit() : returned_resource_count_(0) {} 1716 1717 virtual void BeginTest() OVERRIDE { 1718 activate_count_ = 0; 1719 1720 scoped_ptr<DelegatedFrameData> frame = 1721 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1722 AddTextureQuad(frame.get(), 999); 1723 AddTransferableResource(frame.get(), 999); 1724 SetFrameData(frame.Pass()); 1725 1726 PostSetNeedsCommitToMainThread(); 1727 } 1728 1729 virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE { 1730 ++activate_count_; 1731 } 1732 1733 virtual void DidCommit() OVERRIDE { 1734 switch (layer_tree_host()->source_frame_number()) { 1735 case 1: { 1736 // The first frame has been activated. Set a new frame, and 1737 // expect the next commit to finish *after* it is activated. 1738 scoped_ptr<DelegatedFrameData> frame = 1739 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1740 AddTextureQuad(frame.get(), 555); 1741 AddTransferableResource(frame.get(), 555); 1742 SetFrameData(frame.Pass()); 1743 break; 1744 } 1745 case 2: 1746 // The second frame has been activated. Remove the layer from 1747 // the tree to cause another commit/activation. The commit should 1748 // finish *after* the layer is removed from the active tree. 1749 delegated_->RemoveFromParent(); 1750 break; 1751 case 3: 1752 // Finish the test by releasing resources on the next frame. 1753 scoped_ptr<DelegatedFrameData> frame = 1754 CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1755 SetFrameData(frame.Pass()); 1756 break; 1757 } 1758 } 1759 1760 virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE { 1761 switch (host_impl->active_tree()->source_frame_number()) { 1762 case 0: { 1763 // The activate for the 1st frame should have happened before now. 1764 EXPECT_EQ(1, activate_count_); 1765 break; 1766 } 1767 case 1: { 1768 // The activate for the 2nd frame should have happened before now. 1769 EXPECT_EQ(2, activate_count_); 1770 break; 1771 } 1772 case 2: { 1773 // The activate to remove the layer should have happened before now. 1774 EXPECT_EQ(3, activate_count_); 1775 break; 1776 } 1777 case 3: { 1778 NOTREACHED(); 1779 break; 1780 } 1781 } 1782 } 1783 1784 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1785 bool result) OVERRIDE { 1786 ReturnUnusedResourcesFromParent(host_impl); 1787 } 1788 1789 virtual void UnusedResourcesAreAvailable() OVERRIDE { 1790 LayerTreeHostDelegatedTestCaseSingleDelegatedLayer:: 1791 UnusedResourcesAreAvailable(); 1792 ReturnedResourceArray resources; 1793 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1794 EXPECT_TRUE(TestAndResetAvailable()); 1795 returned_resource_count_ += resources.size(); 1796 if (returned_resource_count_ == 2) 1797 EndTest(); 1798 } 1799 1800 int activate_count_; 1801 size_t returned_resource_count_; 1802}; 1803 1804SINGLE_AND_MULTI_THREAD_TEST_F( 1805 DelegatedFrameIsActivatedDuringCommit); 1806 1807class LayerTreeHostDelegatedTestTwoImplLayers 1808 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1809 public: 1810 virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); } 1811 1812 virtual void DidCommitAndDrawFrame() OVERRIDE { 1813 scoped_ptr<DelegatedFrameData> frame; 1814 ReturnedResourceArray resources; 1815 1816 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1817 switch (next_source_frame_number) { 1818 case 1: 1819 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1820 AddTextureQuad(frame.get(), 999); 1821 AddTransferableResource(frame.get(), 999); 1822 AddTextureQuad(frame.get(), 555); 1823 AddTransferableResource(frame.get(), 555); 1824 SetFrameData(frame.Pass()); 1825 break; 1826 case 2: 1827 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1828 EXPECT_EQ(0u, resources.size()); 1829 EXPECT_FALSE(TestAndResetAvailable()); 1830 1831 // Remove the delegated layer and replace it with a new one. Use the 1832 // same frame and resources for it. 1833 delegated_->RemoveFromParent(); 1834 delegated_ = CreateDelegatedLayer(frame_provider_.get()); 1835 break; 1836 case 3: 1837 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1838 EXPECT_EQ(0u, resources.size()); 1839 EXPECT_FALSE(TestAndResetAvailable()); 1840 1841 // Use a frame with no resources in it. 1842 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1843 SetFrameData(frame.Pass()); 1844 break; 1845 case 4: 1846 // We gave one frame to the frame provider, so we should get one 1847 // ref back for each resource. 1848 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1849 { 1850 unsigned expected[] = {555, 999}; 1851 EXPECT_RESOURCES(expected, resources); 1852 EXPECT_TRUE(TestAndResetAvailable()); 1853 } 1854 EndTest(); 1855 break; 1856 } 1857 } 1858 1859 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1860 bool result) OVERRIDE { 1861 ReturnUnusedResourcesFromParent(host_impl); 1862 } 1863}; 1864 1865SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestTwoImplLayers); 1866 1867class LayerTreeHostDelegatedTestTwoImplLayersTwoFrames 1868 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1869 public: 1870 virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); } 1871 1872 virtual void DidCommitAndDrawFrame() OVERRIDE { 1873 scoped_ptr<DelegatedFrameData> frame; 1874 ReturnedResourceArray resources; 1875 1876 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1877 switch (next_source_frame_number) { 1878 case 1: 1879 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1880 AddTextureQuad(frame.get(), 999); 1881 AddTransferableResource(frame.get(), 999); 1882 AddTextureQuad(frame.get(), 555); 1883 AddTransferableResource(frame.get(), 555); 1884 SetFrameData(frame.Pass()); 1885 break; 1886 case 2: 1887 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1888 EXPECT_EQ(0u, resources.size()); 1889 EXPECT_FALSE(TestAndResetAvailable()); 1890 1891 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1892 AddTextureQuad(frame.get(), 999); 1893 AddTransferableResource(frame.get(), 999); 1894 AddTextureQuad(frame.get(), 555); 1895 AddTransferableResource(frame.get(), 555); 1896 1897 // Remove the delegated layer and replace it with a new one. Make a new 1898 // frame but with the same resources for it. 1899 delegated_->RemoveFromParent(); 1900 delegated_ = NULL; 1901 1902 frame_provider_->SetFrameData(frame.Pass()); 1903 delegated_ = CreateDelegatedLayer(frame_provider_.get()); 1904 break; 1905 case 3: 1906 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1907 EXPECT_EQ(0u, resources.size()); 1908 EXPECT_FALSE(TestAndResetAvailable()); 1909 1910 // Use a frame with no resources in it. 1911 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1912 SetFrameData(frame.Pass()); 1913 break; 1914 case 4: 1915 // We gave two frames to the frame provider, so we should get two 1916 // refs back for each resource. 1917 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1918 { 1919 unsigned expected[] = {555, 555, 999, 999}; 1920 EXPECT_RESOURCES(expected, resources); 1921 EXPECT_TRUE(TestAndResetAvailable()); 1922 } 1923 EndTest(); 1924 break; 1925 } 1926 } 1927 1928 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 1929 bool result) OVERRIDE { 1930 ReturnUnusedResourcesFromParent(host_impl); 1931 } 1932}; 1933 1934SINGLE_AND_MULTI_THREAD_TEST_F( 1935 LayerTreeHostDelegatedTestTwoImplLayersTwoFrames); 1936 1937class LayerTreeHostDelegatedTestTwoLayers 1938 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 1939 public: 1940 virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); } 1941 1942 virtual void DidCommitAndDrawFrame() OVERRIDE { 1943 scoped_ptr<DelegatedFrameData> frame; 1944 ReturnedResourceArray resources; 1945 1946 int next_source_frame_number = layer_tree_host()->source_frame_number(); 1947 switch (next_source_frame_number) { 1948 case 1: 1949 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 1950 AddTextureQuad(frame.get(), 999); 1951 AddTransferableResource(frame.get(), 999); 1952 AddTextureQuad(frame.get(), 555); 1953 AddTransferableResource(frame.get(), 555); 1954 1955 // Create a DelegatedRendererLayer using the frame. 1956 SetFrameData(frame.Pass()); 1957 break; 1958 case 2: 1959 // Create a second DelegatedRendererLayer using the same frame provider. 1960 delegated_thief_ = CreateDelegatedLayer(frame_provider_.get()); 1961 root_->AddChild(delegated_thief_); 1962 1963 // And drop our ref on the frame provider so only the layers keep it 1964 // alive. 1965 frame_provider_ = NULL; 1966 break; 1967 case 3: 1968 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1969 EXPECT_EQ(0u, resources.size()); 1970 EXPECT_FALSE(TestAndResetAvailable()); 1971 1972 // Remove one delegated layer from the tree. No resources should be 1973 // returned yet. 1974 delegated_->RemoveFromParent(); 1975 break; 1976 case 4: 1977 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1978 EXPECT_EQ(0u, resources.size()); 1979 EXPECT_FALSE(TestAndResetAvailable()); 1980 1981 // Put the first layer back, and remove the other layer and destroy it. 1982 // No resources should be returned yet. 1983 root_->AddChild(delegated_); 1984 delegated_thief_->RemoveFromParent(); 1985 delegated_thief_ = NULL; 1986 break; 1987 case 5: 1988 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1989 EXPECT_EQ(0u, resources.size()); 1990 EXPECT_FALSE(TestAndResetAvailable()); 1991 1992 // Remove the first layer from the tree again. The resources are still 1993 // held by the main thread layer. 1994 delegated_->RemoveFromParent(); 1995 break; 1996 case 6: 1997 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 1998 EXPECT_EQ(0u, resources.size()); 1999 EXPECT_FALSE(TestAndResetAvailable()); 2000 2001 // Destroy the layer and the resources should be returned immediately. 2002 delegated_ = NULL; 2003 2004 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2005 { 2006 unsigned expected[] = {555, 999}; 2007 EXPECT_RESOURCES(expected, resources); 2008 EXPECT_TRUE(TestAndResetAvailable()); 2009 } 2010 EndTest(); 2011 break; 2012 } 2013 } 2014 2015 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 2016 bool result) OVERRIDE { 2017 ReturnUnusedResourcesFromParent(host_impl); 2018 } 2019 2020 scoped_refptr<DelegatedRendererLayer> delegated_thief_; 2021}; 2022 2023SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestTwoLayers); 2024 2025class LayerTreeHostDelegatedTestRemoveAndAddToTree 2026 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 2027 public: 2028 virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); } 2029 2030 virtual void DidCommitAndDrawFrame() OVERRIDE { 2031 scoped_ptr<DelegatedFrameData> frame; 2032 ReturnedResourceArray resources; 2033 2034 int next_source_frame_number = layer_tree_host()->source_frame_number(); 2035 switch (next_source_frame_number) { 2036 case 1: 2037 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 2038 AddTextureQuad(frame.get(), 999); 2039 AddTransferableResource(frame.get(), 999); 2040 AddTextureQuad(frame.get(), 555); 2041 AddTransferableResource(frame.get(), 555); 2042 2043 // Create a DelegatedRendererLayer using the frame. 2044 SetFrameData(frame.Pass()); 2045 break; 2046 case 2: 2047 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2048 EXPECT_EQ(0u, resources.size()); 2049 EXPECT_FALSE(TestAndResetAvailable()); 2050 2051 // Remove the layer from the tree. The resources should not be returned 2052 // since they are still on the main thread layer. 2053 delegated_->RemoveFromParent(); 2054 break; 2055 case 3: 2056 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2057 EXPECT_EQ(0u, resources.size()); 2058 EXPECT_FALSE(TestAndResetAvailable()); 2059 2060 // Add the layer back to the tree. 2061 layer_tree_host()->root_layer()->AddChild(delegated_); 2062 break; 2063 case 4: 2064 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2065 EXPECT_EQ(0u, resources.size()); 2066 EXPECT_FALSE(TestAndResetAvailable()); 2067 2068 // Set a new frame. Resources should be returned. 2069 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 2070 AddTextureQuad(frame.get(), 888); 2071 AddTransferableResource(frame.get(), 888); 2072 AddTextureQuad(frame.get(), 777); 2073 AddTransferableResource(frame.get(), 777); 2074 SetFrameData(frame.Pass()); 2075 break; 2076 case 5: 2077 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2078 { 2079 unsigned expected[] = {555, 999}; 2080 EXPECT_RESOURCES(expected, resources); 2081 EXPECT_TRUE(TestAndResetAvailable()); 2082 } 2083 2084 // Destroy the layer. 2085 delegated_->RemoveFromParent(); 2086 delegated_ = NULL; 2087 break; 2088 case 6: 2089 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2090 EXPECT_EQ(0u, resources.size()); 2091 EXPECT_FALSE(TestAndResetAvailable()); 2092 2093 // Destroy the frame provider. Resources should be returned. 2094 frame_provider_ = NULL; 2095 2096 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2097 { 2098 unsigned expected[] = {777, 888}; 2099 EXPECT_RESOURCES(expected, resources); 2100 EXPECT_TRUE(TestAndResetAvailable()); 2101 } 2102 EndTest(); 2103 break; 2104 } 2105 } 2106 2107 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 2108 bool result) OVERRIDE { 2109 ReturnUnusedResourcesFromParent(host_impl); 2110 } 2111 2112 scoped_refptr<DelegatedRendererLayer> delegated_thief_; 2113}; 2114 2115SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemoveAndAddToTree); 2116 2117class LayerTreeHostDelegatedTestRemoveAndChangeResources 2118 : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer { 2119 public: 2120 virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); } 2121 2122 virtual void DidCommitAndDrawFrame() OVERRIDE { 2123 scoped_ptr<DelegatedFrameData> frame; 2124 ReturnedResourceArray resources; 2125 2126 int next_source_frame_number = layer_tree_host()->source_frame_number(); 2127 switch (next_source_frame_number) { 2128 case 1: 2129 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 2130 AddTextureQuad(frame.get(), 999); 2131 AddTransferableResource(frame.get(), 999); 2132 AddTextureQuad(frame.get(), 555); 2133 AddTransferableResource(frame.get(), 555); 2134 2135 // Create a DelegatedRendererLayer using the frame. 2136 SetFrameData(frame.Pass()); 2137 break; 2138 case 2: 2139 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2140 EXPECT_EQ(0u, resources.size()); 2141 EXPECT_FALSE(TestAndResetAvailable()); 2142 2143 // Remove the layer from the tree. The resources should not be returned 2144 // since they are still on the main thread layer. 2145 delegated_->RemoveFromParent(); 2146 break; 2147 case 3: 2148 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2149 EXPECT_EQ(0u, resources.size()); 2150 EXPECT_FALSE(TestAndResetAvailable()); 2151 2152 // Set a new frame. Resources should be returned immediately. 2153 frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)); 2154 AddTextureQuad(frame.get(), 888); 2155 AddTransferableResource(frame.get(), 888); 2156 AddTextureQuad(frame.get(), 777); 2157 AddTransferableResource(frame.get(), 777); 2158 SetFrameData(frame.Pass()); 2159 2160 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2161 { 2162 unsigned expected[] = {555, 999}; 2163 EXPECT_RESOURCES(expected, resources); 2164 EXPECT_TRUE(TestAndResetAvailable()); 2165 resources.clear(); 2166 } 2167 2168 // Destroy the frame provider. 2169 frame_provider_ = NULL; 2170 2171 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2172 EXPECT_EQ(0u, resources.size()); 2173 EXPECT_FALSE(TestAndResetAvailable()); 2174 2175 // Destroy the layer. Resources should be returned. 2176 delegated_ = NULL; 2177 2178 resource_collection_->TakeUnusedResourcesForChildCompositor(&resources); 2179 { 2180 unsigned expected[] = {777, 888}; 2181 EXPECT_RESOURCES(expected, resources); 2182 EXPECT_TRUE(TestAndResetAvailable()); 2183 } 2184 EndTest(); 2185 break; 2186 } 2187 } 2188 2189 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, 2190 bool result) OVERRIDE { 2191 ReturnUnusedResourcesFromParent(host_impl); 2192 } 2193 2194 scoped_refptr<DelegatedRendererLayer> delegated_thief_; 2195}; 2196 2197SINGLE_AND_MULTI_THREAD_TEST_F( 2198 LayerTreeHostDelegatedTestRemoveAndChangeResources); 2199 2200} // namespace 2201} // namespace cc 2202