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