cc: Keep track of busy resources in ResourcePool

cc/resources/resource_pool.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_pool.h"
 
 #include "cc/resources/resource_provider.h"
 
 namespace cc {
 
@@ skipping 29 matching lines @@
 
 ResourcePool::~ResourcePool() {
   SetResourceUsageLimits(0, 0, 0);
 }
 
 scoped_ptr<ResourcePool::Resource> ResourcePool::AcquireResource(
     gfx::Size size, ResourceFormat format) {
   for (ResourceList::iterator it = unused_resources_.begin();
        it != unused_resources_.end(); ++it) {
     Resource* resource = *it;
+    DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
-    if (!resource_provider_->CanLockForWrite(resource->id()))
-      continue;
     if (resource->size() != size)
       continue;
     if (resource->format() != format)
       continue;
 
     unused_resources_.erase(it);
     unused_memory_usage_bytes_ -= resource->bytes();
     return make_scoped_ptr(resource);
   }
 
   // Create new resource.
   Resource* resource = new Resource(resource_provider_, size, format);
 
   // Extend all read locks on all resources until the resource is
   // finished being used, such that we know when resources are
   // truly safe to recycle.
   resource_provider_->EnableReadLockFences(resource->id(), true);
 
   memory_usage_bytes_ += resource->bytes();
   ++resource_count_;
   return make_scoped_ptr(resource);
 }
 
 void ResourcePool::ReleaseResource(
     scoped_ptr<ResourcePool::Resource> resource) {
-  if (ResourceUsageTooHigh()) {
-    memory_usage_bytes_ -= resource->bytes();
-    --resource_count_;
-    return;
-  }
-
   unused_memory_usage_bytes_ += resource->bytes();

[reveman, 2013/11/05 15:38:27]

This needs to be moved to CheckBusyResources() as only resources that can be
freed should count against unused_memory_usage_bytes_.

-  unused_resources_.push_back(resource.release());
+  busy_resources_.push_back(resource.release());
 }
 
 void ResourcePool::SetResourceUsageLimits(
     size_t max_memory_usage_bytes,
     size_t max_unused_memory_usage_bytes,
     size_t max_resource_count) {
   max_memory_usage_bytes_ = max_memory_usage_bytes;
   max_unused_memory_usage_bytes_ = max_unused_memory_usage_bytes;
   max_resource_count_ = max_resource_count;
 
@@ skipping 24 matching lines @@
 bool ResourcePool::ResourceUsageTooHigh() {
   if (resource_count_ > max_resource_count_)
     return true;
   if (memory_usage_bytes_ > max_memory_usage_bytes_)
     return true;
   if (unused_memory_usage_bytes_ > max_unused_memory_usage_bytes_)
     return true;
   return false;
 }
 
+void ResourcePool::CheckBusyResources() {
+  ResourceList::iterator it = busy_resources_.begin();
+
+  while (it != busy_resources_.end()) {
+    Resource* resource = *it;
+
+    if (resource_provider_->CanLockForWrite(resource->id())) {
+      unused_resources_.push_back(resource);
+      it = busy_resources_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 }  // namespace cc