cc/trees/layer_tree_host_unittest_delegated.cc

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