cc: Allow getting unused resources from delegated renderer layer.

Adds DelegatedRendererLayer::TakeUnusedResourcesForChildCompositor() method
that returns a list of TransferableResources that were given to the layer
by a child compositor, but are no longer in use by the impl tree.

Tests:
LayerTreeHostDelegatedTestReturnUnusedResources.runSingleThread
LayerTreeHostDelegatedTestReturnUnusedResources.runMultiThread
LayerTreeHostDelegatedTestReusedResources.runSingleThread
LayerTreeHostDelegatedTestReusedResources.runMultiThread

R=piman
BUG=123444

Review URL: https://chromiumcodereview.appspot.com/12374049

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@185660 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 151 insertions, 9 deletions

diff --git a/cc/delegated_renderer_layer.cc b/cc/delegated_renderer_layer.cc
index c6d6779..7e06e4f 100644
--- a/cc/delegated_renderer_layer.cc
+++ b/cc/delegated_renderer_layer.cc
@@ -40,16 +40,15 @@ void DelegatedRendererLayer::pushPropertiesTo(LayerImpl* impl) {
   if (!frame_data_)
     return;
 
-  // TODO(danakj): Save these resources somewhere where we can collect them for
-  // the frame ack.
-  TransferableResourceArray resources_for_ack;
   if (frame_size_.IsEmpty()) {
     scoped_ptr<DelegatedFrameData> empty_frame(new DelegatedFrameData);
-    delegated_impl->SetFrameData(
-        empty_frame.Pass(), gfx::Rect(), &resources_for_ack);
+    delegated_impl->SetFrameData(empty_frame.Pass(),
+                                 gfx::Rect(),
+                                 &unused_resources_for_child_compositor_);
   } else {
-    delegated_impl->SetFrameData(
-        frame_data_.Pass(), damage_in_frame_, &resources_for_ack);
+    delegated_impl->SetFrameData(frame_data_.Pass(),
+                                 damage_in_frame_,
+                                 &unused_resources_for_child_compositor_);
   }
   frame_data_.reset();
   damage_in_frame_ = gfx::RectF();
@@ -82,4 +81,12 @@ void DelegatedRendererLayer::SetFrameData(
   setNeedsCommit();
 }
 
+void DelegatedRendererLayer::TakeUnusedResourcesForChildCompositor(
+    TransferableResourceArray* array) {
+  DCHECK(array->empty());
+  array->clear();
+
+  array->swap(unused_resources_for_child_compositor_);
+}
+
 }  // namespace cc
diff --git a/cc/delegated_renderer_layer.h b/cc/delegated_renderer_layer.h
index 8266b63..ac38abf 100644
--- a/cc/delegated_renderer_layer.h
+++ b/cc/delegated_renderer_layer.h
@@ -7,6 +7,7 @@
 
 #include "cc/cc_export.h"
 #include "cc/layer.h"
+#include "cc/transferable_resource.h"
 
 namespace cc {
 class DelegatedFrameData;
@@ -28,6 +29,10 @@ class CC_EXPORT DelegatedRendererLayer : public Layer {
 
   void SetFrameData(scoped_ptr<DelegatedFrameData> frame_data);
 
+  // Passes ownership of any unused resources that had been given by the child
+  // compositor to the given array, so they can be given back to the child.
+  void TakeUnusedResourcesForChildCompositor(TransferableResourceArray* array);
+
  protected:
   DelegatedRendererLayer();
   virtual ~DelegatedRendererLayer();
@@ -37,6 +42,7 @@ class CC_EXPORT DelegatedRendererLayer : public Layer {
   gfx::RectF damage_in_frame_;
   gfx::Size frame_size_;
   gfx::Size display_size_;
+  TransferableResourceArray unused_resources_for_child_compositor_;
 };
 
 }
diff --git a/cc/layer_tree_host_unittest_delegated.cc b/cc/layer_tree_host_unittest_delegated.cc
index 2e9be79..3db6214 100644
--- a/cc/layer_tree_host_unittest_delegated.cc
+++ b/cc/layer_tree_host_unittest_delegated.cc
@@ -339,7 +339,7 @@ class LayerTreeHostDelegatedTestMergeResources
     AddTransferableResource(frame1.get(), 999);
     delegated_->SetFrameData(frame1.Pass());
 
-    // The second frame uses resource 999 still.
+    // The second frame uses resource 999 still, but also adds 555.
     scoped_ptr<DelegatedFrameData> frame2 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame2.get(), 999);
@@ -381,7 +381,7 @@ class LayerTreeHostDelegatedTestRemapResourcesInQuads
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   virtual void beginTest() OVERRIDE {
-    // Generate a frame with a resource in it.
+    // Generate a frame with two resources in it.
     scoped_ptr<DelegatedFrameData> frame =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame.get(), 999);
@@ -428,5 +428,134 @@ class LayerTreeHostDelegatedTestRemapResourcesInQuads
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemapResourcesInQuads)
 
+class LayerTreeHostDelegatedTestReturnUnusedResources
+    : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
+ public:
+  virtual void beginTest() OVERRIDE {
+    postSetNeedsCommitToMainThread();
+  }
+
+  virtual void didCommit() OVERRIDE {
+    scoped_ptr<DelegatedFrameData> frame;
+    TransferableResourceArray resources;
+
+    int next_source_frame_number = m_layerTreeHost->commitNumber();
+    switch (next_source_frame_number) {
+      case 1:
+        // Generate a frame with two resources in it.
+        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:
+        // All of the resources are in use.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(0u, resources.size());
+
+        // 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);
+        AddTextureQuad(frame.get(), 444);
+        AddTransferableResource(frame.get(), 444);
+        delegated_->SetFrameData(frame.Pass());
+        break;
+      case 3:
+        // 555 is no longer in use.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(1u, resources.size());
+        EXPECT_EQ(555, resources[0].id);
+
+        // 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:
+        // 444 and 999 are no longer in use.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(2u, resources.size());
+        if (resources[0].id == 999) {
+          EXPECT_EQ(999, resources[0].id);
+          EXPECT_EQ(444, resources[1].id);
+        } else {
+          EXPECT_EQ(444, resources[0].id);
+          EXPECT_EQ(999, resources[1].id);
+        }
+        endTest();
+        break;
+    }
+
+    // Resource are never immediately released.
+    TransferableResourceArray empty_resources;
+    delegated_->TakeUnusedResourcesForChildCompositor(&empty_resources);
+    EXPECT_TRUE(empty_resources.empty());
+  }
+
+  virtual void afterTest() OVERRIDE {}
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestReturnUnusedResources)
+
+class LayerTreeHostDelegatedTestReusedResources
+    : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
+ public:
+  virtual void beginTest() OVERRIDE {
+    postSetNeedsCommitToMainThread();
+  }
+
+  virtual void didCommit() OVERRIDE {
+    scoped_ptr<DelegatedFrameData> frame;
+    TransferableResourceArray resources;
+
+    int next_source_frame_number = m_layerTreeHost->commitNumber();
+    switch (next_source_frame_number) {
+      case 1:
+        // Generate a frame with some resources in it.
+        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());
+        break;
+      case 2:
+        // All of the resources are in use.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(0u, resources.size());
+
+        // 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);
+        delegated_->SetFrameData(frame.Pass());
+
+        // Resource are not immediately released.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(0u, resources.size());
+
+        // 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);
+        AddTextureQuad(frame.get(), 444);
+        delegated_->SetFrameData(frame.Pass());
+        break;
+      case 3:
+        // The 999 resource is the only unused one.
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        EXPECT_EQ(1u, resources.size());
+        EXPECT_EQ(999, resources[0].id);
+        endTest();
+        break;
+    }
+  }
+
+  virtual void afterTest() OVERRIDE {}
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestReusedResources)
+
 }  // namespace
 }  // namespace cc