cc: Provide notifications when resources are available.

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 230 matching lines @@
       output_surface()->ReturnResource(resources_to_return[i], &ack);
     host_impl->ReclaimResources(&ack);
     host_impl->OnSwapBuffersComplete();
   }
 };
 
 class LayerTreeHostDelegatedTestCaseSingleDelegatedLayer
     : public LayerTreeHostDelegatedTest,
       public DelegatedRendererLayerClient {
  public:
+  LayerTreeHostDelegatedTestCaseSingleDelegatedLayer() : available_(false) {}
+
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(gfx::Size(10, 10));
 
     delegated_ = FakeDelegatedRendererLayer::Create(this);
     delegated_->SetAnchorPoint(gfx::PointF());
     delegated_->SetBounds(gfx::Size(10, 10));
     delegated_->SetIsDrawable(true);
 
     root_->AddChild(delegated_);
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostDelegatedTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
+  // DelegatedRendererLayerClient implementation.
   virtual void DidCommitFrameData() OVERRIDE {}
+  virtual void UnusedResourcesAreAvailable() OVERRIDE { available_ = true; }
+
+  bool TestAndResetAvailable() {
+    bool available = available_;
+    available_ = false;
+    return available;
+  }
 
  protected:
   scoped_refptr<Layer> root_;
   scoped_refptr<DelegatedRendererLayer> delegated_;
+  bool available_;
 };
 
 class LayerTreeHostDelegatedTestClientDidCommitCallback
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   LayerTreeHostDelegatedTestClientDidCommitCallback()
       : LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
         num_did_commit_frame_data_(0) {}
 
   virtual void DidCommit() OVERRIDE {
@@ skipping 452 matching lines @@
     AddTransferableResource(frame2.get(), 555);
     delegated_->SetFrameData(frame2.Pass());
 
     // The resource 999 from frame1 is returned since it is still on the main
     // thread.
     ReturnedResourceArray returned_resources;
     delegated_->TakeUnusedResourcesForChildCompositor(&returned_resources);
     {
       unsigned expected[] = {999};
       EXPECT_RESOURCES(expected, returned_resources);
+      EXPECT_TRUE(TestAndResetAvailable());
     }
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
@@ skipping 88 matching lines @@
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
         // 555 is no longer in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // Stop using any resources.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         delegated_->SetFrameData(frame.Pass());
         break;
       case 4:
         // Postpone collecting resources for a frame. They should still be there
         // the next frame.
         layer_tree_host()->SetNeedsCommit();
         return;
       case 5:
         // 444 and 999 are no longer in use. We sent two refs to 999, so we
         // should get two back.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 999, 999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
 
-    // Resource are never immediately released.
+    // Resources are never immediately released.
     ReturnedResourceArray empty_resources;
     delegated_->TakeUnusedResourcesForChildCompositor(&empty_resources);
-    EXPECT_TRUE(empty_resources.empty());
+    EXPECT_EQ(0u, empty_resources.size());
+    EXPECT_FALSE(TestAndResetAvailable());
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
@@ skipping 21 matching lines @@
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Now using 555 and 444 again, but not 999.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
         // The 999 resource is the only unused one. Two references were sent, so
         // two should be returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {999, 999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
@@ skipping 24 matching lines @@
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // The child compositor sends a frame referring to resources not in the
         // frame.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
@@ skipping 61 matching lines @@
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         // The child compositor sends a frame before taking resources back
         // from the previous commit. This frame makes use of the resources 555
         // and 444, which were just released during commit.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
 
         // The resources are used by the new frame but are returned anyway since
         // we passed them again.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
         break;
       case 4:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
@@ skipping 59 matching lines @@
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Generate a bad frame with a resource the layer doesn't have. The
         // 885 and 775 resources are unknown, while ownership of the legit 444
         // resource is passed in here. The bad frame does not use any of the
         // previous resources, 999 or 555.
         // A bad quad is present both before and after the good quad.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 885);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         AddTextureQuad(frame.get(), 775);
         delegated_->SetFrameData(frame.Pass());
 
         // The parent compositor (this one) does a commit.
         break;
       case 3:
         // The bad frame's resource is given back to the child compositor.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         // Now send a good frame with 999 again.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 4:
         // The unused 555 from the last good frame is now released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
@@ skipping 96 matching lines @@
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // The unused resource should be returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
@@ skipping 47 matching lines @@
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // The unused resources should be returned. 555 is still used, but it's
         // returned once to account for the first frame.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
         // Send a frame with no resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
         // The now unused resource 555 should be returned.
         resources.clear();
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
@@ skipping 37 matching lines @@
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // 999 is in use in the grandparent compositor, generate a frame without
         // it present.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
         // Since 999 is in the grandparent it is not returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // The impl side will get back the resource at some point.
         ImplThreadTaskRunner()->PostTask(FROM_HERE,
                                          receive_resource_on_thread_);
         break;
     }
   }
 
   void ReceiveResourceOnThread(LayerTreeHostImpl* host_impl) {
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // Receive 999 back from the grandparent.
     CompositorFrameAck ack;
     output_surface()->ReturnResource(map.find(999)->second, &ack);
     host_impl->ReclaimResources(&ack);
     host_impl->OnSwapBuffersComplete();
-
-    // And then it should be released by the DelegatedRendererLayer.
-    MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostDelegatedTestResourceSentToParent::
-                        DidReceiveResourceOnMainThread,
-                   base::Unretained(this)));
   }
 
-  void DidReceiveResourceOnMainThread() {
+  virtual void UnusedResourcesAreAvailable() OVERRIDE {
+    EXPECT_EQ(3, layer_tree_host()->source_frame_number());
+
     ReturnedResourceArray resources;
 
     // 999 was returned from the grandparent and could be released.
     delegated_->TakeUnusedResourcesForChildCompositor(&resources);
     {
       unsigned expected[] = {999};
       EXPECT_RESOURCES(expected, resources);
     }
 
     EndTest();
@@ skipping 80 matching lines @@
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
+        EXPECT_FALSE(TestAndResetAvailable());
 
         // Stop using 999 and 444 in this frame and commit.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         // 999 and 444 will be returned for frame 1, but not 555 since it's in
         // the current frame.
         break;
       case 3:
         // Don't take resources here, but set a new frame that uses 999 again.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 4:
         // 555 from frame 1 and 2 isn't returned since it's still in use. 999
         // from frame 1 is returned though.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         delegated_->SetFrameData(frame.Pass());
         // 555 will be returned 3 times for frames 1 2 and 3, and 999 will be
         // returned once for frame 3.
         break;
       case 5:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 555, 555, 999};
           EXPECT_RESOURCES(expected, resources);
+          EXPECT_TRUE(TestAndResetAvailable());
         }
 
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
@@ skipping 138 matching lines @@
   base::WaitableEvent wait_event_;
   base::Lock activate_lock_;
   int activate_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     DelegatedFrameIsActivatedDuringCommit);
 
 }  // namespace
 }  // namespace cc