Return overlay resources to renderers in larger batches.

cc/resources/resource_provider.cc

 // Copyright 2012 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/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1015 matching lines @@
 
   Resource* resource = &it->second;
   DCHECK_GT(resource->lock_for_read_count, 0);
   DCHECK_EQ(resource->exported_count, 0);
   resource->lock_for_read_count--;
   if (resource->marked_for_deletion && !resource->lock_for_read_count) {
     if (!resource->child_id) {
       // The resource belongs to this ResourceProvider, so it can be destroyed.
       DeleteResourceInternal(it, NORMAL);
     } else {
-      ChildMap::iterator child_it = children_.find(resource->child_id);
-      ResourceIdArray unused;
-      unused.push_back(id);
-      DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, unused);
+      if (batch_return_resources_) {
+        batched_returning_resources_[resource->child_id].push_back(id);
+      } else {
+        ChildMap::iterator child_it = children_.find(resource->child_id);
+        ResourceIdArray unused;
+        unused.push_back(id);
+        DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, unused);
+      }
     }
   }
 }
 
 ResourceProvider::Resource* ResourceProvider::LockForWrite(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(CanLockForWrite(id));
   if (resource->allocated)
     WaitSyncTokenIfNeeded(id);
   resource->locked_for_write = true;
@@ skipping 298 matching lines @@
 gfx::GpuMemoryBuffer*
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
   if (!gpu_memory_buffer_) {
     gpu_memory_buffer_ =
         resource_provider_->gpu_memory_buffer_manager_->CreateGpuMemoryBuffer(
             size_, BufferFormat(format_), usage_, gpu::kNullSurfaceHandle);
   }
   return gpu_memory_buffer_.get();
 }
 
+ResourceProvider::ScopedBatchReturnResources::ScopedBatchReturnResources(
+    ResourceProvider* resource_provider)
+    : resource_provider_(resource_provider) {
+  resource_provider_->SetBatchReturnResources(true);
+}
+
+ResourceProvider::ScopedBatchReturnResources::~ScopedBatchReturnResources() {
+  resource_provider_->SetBatchReturnResources(false);
+}
+
 ResourceProvider::SynchronousFence::SynchronousFence(
     gpu::gles2::GLES2Interface* gl)
     : gl_(gl), has_synchronized_(true) {}
 
 ResourceProvider::SynchronousFence::~SynchronousFence() {}
 
 void ResourceProvider::SynchronousFence::Set() {
   has_synchronized_ = false;
 }
 
@@ skipping 288 matching lines @@
     resources_for_child[resource->child_id].push_back(local_id);
   }
 
   for (const auto& children : resources_for_child) {
     ChildMap::iterator child_it = children_.find(children.first);
     DCHECK(child_it != children_.end());
     DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, children.second);
   }
 }
 
+void ResourceProvider::SetBatchReturnResources(bool batch) {
+  DCHECK_NE(batch_return_resources_, batch);
+  batch_return_resources_ = batch;
+  if (!batch) {
+    for (const auto& resources : batched_returning_resources_) {
+      ChildMap::iterator child_it = children_.find(resources.first);
+      DCHECK(child_it != children_.end());
+      DeleteAndReturnUnusedResourcesToChild(child_it, NORMAL, resources.second);
+    }
+    batched_returning_resources_.clear();
+  }
+}
+
 #if defined(OS_ANDROID)
 void ResourceProvider::SendPromotionHints(
     const OverlayCandidateList::PromotionHintInfoMap& promotion_hints) {
   GLES2Interface* gl = ContextGL();
   if (!gl)
     return;
 
   for (const auto& id : wants_promotion_hints_set_) {
     const ResourceMap::iterator it = resources_.find(id);
     if (it == resources_.end())
@@ skipping 466 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc