aura: Return unused delegated resources immediately if no ack pending.

When a resource becomes available for return to the child compositor,
if we're not waiting on sending them a frame ack already, then send
the resources back immediately so that they can be reused on the child.

If the output surface from the child changes, then lose all the
resources held by the RenderWidgetHostViewAura immediately, and return
them to the child, so that the DelegatedFrameResourceCollection
can be destroyed and resources are not left unaccounted for.

Tests:
DelegatedFrameProviderTest.LostNothing
DelegatedFrameProviderTest.LostSomething
DelegatedFrameProviderTest.NothingReturnedAfterLoss

R=piman@chromium.org, piman
BUG=263069

Review URL: https://codereview.chromium.org/26999003

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

3 files changed, 113 insertions, 9 deletions

diff --git a/cc/layers/delegated_frame_provider_unittest.cc b/cc/layers/delegated_frame_provider_unittest.cc
index b4ae1d9..871b421 100644
--- a/cc/layers/delegated_frame_provider_unittest.cc
+++ b/cc/layers/delegated_frame_provider_unittest.cc
@@ -150,9 +150,9 @@ TEST_F(DelegatedFrameProviderTest, RefResources) {
   SetFrameProvider(frame.Pass());
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
   scoped_refptr<DelegatedRendererLayer> observer2 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
 
   gfx::RectF damage;
 
@@ -208,9 +208,9 @@ TEST_F(DelegatedFrameProviderTest, RefResourcesInFrameProvider) {
   SetFrameProvider(frame.Pass());
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
   scoped_refptr<DelegatedRendererLayer> observer2 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
 
   gfx::RectF damage;
 
@@ -250,9 +250,9 @@ TEST_F(DelegatedFrameProviderTest, RefResourcesInFrameProviderUntilDestroy) {
   SetFrameProvider(frame.Pass());
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
   scoped_refptr<DelegatedRendererLayer> observer2 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
 
   gfx::RectF damage;
 
@@ -294,9 +294,9 @@ TEST_F(DelegatedFrameProviderTest, Damage) {
   SetFrameProvider(frame.Pass());
 
   scoped_refptr<DelegatedRendererLayer> observer1 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
   scoped_refptr<DelegatedRendererLayer> observer2 =
-      DelegatedRendererLayer::Create(NULL, frame_provider_.get());
+      DelegatedRendererLayer::Create(NULL, frame_provider_);
 
   gfx::RectF damage;
 
@@ -330,5 +330,66 @@ TEST_F(DelegatedFrameProviderTest, Damage) {
   EXPECT_EQ(gfx::RectF().ToString(), damage.ToString());
 }
 
+TEST_F(DelegatedFrameProviderTest, LostNothing) {
+  scoped_ptr<DelegatedFrameData> frame =
+      CreateFrameData(gfx::Rect(5, 5), gfx::Rect(5, 5));
+
+  TransferableResourceArray reffed = frame->resource_list;
+
+  SetFrameProvider(frame.Pass());
+
+  // There is nothing to lose.
+  EXPECT_FALSE(ReturnAndResetResourcesAvailable());
+  EXPECT_FALSE(resource_collection_->LoseAllResources());
+  EXPECT_FALSE(ReturnAndResetResourcesAvailable());
+  EXPECT_EQ(0u, resources_.size());
+}
+
+TEST_F(DelegatedFrameProviderTest, LostSomething) {
+  scoped_ptr<DelegatedFrameData> frame =
+      CreateFrameData(gfx::Rect(5, 5), gfx::Rect(5, 5));
+  AddTextureQuad(frame.get(), 444);
+  AddTransferableResource(frame.get(), 444);
+
+  SetFrameProvider(frame.Pass());
+
+  // Add a second reference on the resource.
+  frame = CreateFrameData(gfx::Rect(5, 5), gfx::Rect(5, 5));
+  AddTextureQuad(frame.get(), 444);
+  AddTransferableResource(frame.get(), 444);
+
+  SetFrameProvider(frame.Pass());
+
+  // There is something to lose.
+  EXPECT_FALSE(ReturnAndResetResourcesAvailable());
+  EXPECT_TRUE(resource_collection_->LoseAllResources());
+  EXPECT_TRUE(ReturnAndResetResourcesAvailable());
+
+  EXPECT_EQ(1u, resources_.size());
+  EXPECT_EQ(444u, resources_[0].id);
+  EXPECT_EQ(2, resources_[0].count);
+}
+
+TEST_F(DelegatedFrameProviderTest, NothingReturnedAfterLoss) {
+  scoped_ptr<DelegatedFrameData> frame =
+      CreateFrameData(gfx::Rect(1, 1), gfx::Rect(1, 1));
+  AddTextureQuad(frame.get(), 444);
+  AddTransferableResource(frame.get(), 444);
+  SetFrameProvider(frame.Pass());
+
+  EXPECT_FALSE(ReturnAndResetResourcesAvailable());
+
+  // Lose all the resources.
+  EXPECT_TRUE(resource_collection_->LoseAllResources());
+  EXPECT_TRUE(ReturnAndResetResourcesAvailable());
+  resources_.clear();
+
+  frame_provider_ = NULL;
+
+  // Nothing is returned twice.
+  EXPECT_FALSE(ReturnAndResetResourcesAvailable());
+  EXPECT_EQ(0u, resources_.size());
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/layers/delegated_frame_resource_collection.cc b/cc/layers/delegated_frame_resource_collection.cc
index ee679fa..cd2633d 100644
--- a/cc/layers/delegated_frame_resource_collection.cc
+++ b/cc/layers/delegated_frame_resource_collection.cc
@@ -10,7 +10,9 @@
 namespace cc {
 
 DelegatedFrameResourceCollection::DelegatedFrameResourceCollection()
-    : client_(NULL), main_thread_runner_(BlockingTaskRunner::current()) {
+    : client_(NULL),
+      main_thread_runner_(BlockingTaskRunner::current()),
+      lost_all_resources_(false) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 }
 
@@ -30,9 +32,42 @@ void DelegatedFrameResourceCollection::TakeUnusedResourcesForChildCompositor(
   array->swap(returned_resources_for_child_compositor_);
 }
 
+bool DelegatedFrameResourceCollection::LoseAllResources() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  DCHECK(!lost_all_resources_);
+  lost_all_resources_ = true;
+
+  if (resource_id_ref_count_map_.empty())
+    return false;
+
+  ReturnedResourceArray to_return;
+
+  for (ResourceIdRefCountMap::iterator it = resource_id_ref_count_map_.begin();
+       it != resource_id_ref_count_map_.end();
+       ++it) {
+    DCHECK_GE(it->second.refs_to_wait_for, 1);
+
+    ReturnedResource returned;
+    returned.id = it->first;
+    returned.count = it->second.refs_to_return;
+    returned.lost = true;
+    to_return.push_back(returned);
+  }
+
+  returned_resources_for_child_compositor_.insert(
+      returned_resources_for_child_compositor_.end(),
+      to_return.begin(),
+      to_return.end());
+  if (client_)
+    client_->UnusedResourcesAreAvailable();
+  return true;
+}
+
 void DelegatedFrameResourceCollection::ReceivedResources(
     const TransferableResourceArray& resources) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
+  DCHECK(!lost_all_resources_);
+
   for (size_t i = 0; i < resources.size(); ++i)
     resource_id_ref_count_map_[resources[i].id].refs_to_return++;
 }
@@ -41,6 +76,9 @@ void DelegatedFrameResourceCollection::UnrefResources(
     const ReturnedResourceArray& returned) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
+  if (lost_all_resources_)
+    return;
+
   ReturnedResourceArray to_return;
 
   for (size_t i = 0; i < returned.size(); ++i) {
diff --git a/cc/layers/delegated_frame_resource_collection.h b/cc/layers/delegated_frame_resource_collection.h
index f5d4a4d..68ee11a 100644
--- a/cc/layers/delegated_frame_resource_collection.h
+++ b/cc/layers/delegated_frame_resource_collection.h
@@ -32,6 +32,10 @@ class CC_EXPORT DelegatedFrameResourceCollection
 
   void TakeUnusedResourcesForChildCompositor(ReturnedResourceArray* array);
 
+  // Considers all resources as lost, and returns true if it held any resource
+  // to lose.
+  bool LoseAllResources();
+
   // Methods for DelegatedFrameProvider.
   void RefResources(const TransferableResourceArray& resources);
   void UnrefResources(const ReturnedResourceArray& returned);
@@ -50,6 +54,7 @@ class CC_EXPORT DelegatedFrameResourceCollection
   scoped_refptr<BlockingTaskRunner> main_thread_runner_;
 
   ReturnedResourceArray returned_resources_for_child_compositor_;
+  bool lost_all_resources_;
 
   struct RefCount {
     int refs_to_return;