Refactor ResourcePool::AcquireResource() and add test.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 76 matching lines @@
     DidFinishUsingResource(PopBack(&busy_resources_));
   }
 
   SetResourceUsageLimits(0, 0);
   DCHECK_EQ(0u, unused_resources_.size());
   DCHECK_EQ(0u, in_use_memory_usage_bytes_);
   DCHECK_EQ(0u, total_memory_usage_bytes_);
   DCHECK_EQ(0u, total_resource_count_);
 }
 
-Resource* ResourcePool::AcquireResource(const gfx::Size& size,
-                                        ResourceFormat format,
-                                        const gfx::ColorSpace& color_space) {
+Resource* ResourcePool::ReuseResource(const gfx::Size& size,
+                                      ResourceFormat format,
+                                      const gfx::ColorSpace& color_space) {
   // Finding resources in |unused_resources_| from MRU to LRU direction, touches
   // LRU resources only if needed, which increases possibility of expiring more
   // LRU resources within kResourceExpirationDelayMs.
   for (ResourceDeque::iterator it = unused_resources_.begin();
        it != unused_resources_.end(); ++it) {
     ScopedResource* resource = it->get();
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
     if (resource->color_space() != color_space)
       continue;
 
     // Transfer resource to |in_use_resources_|.
     in_use_resources_[resource->id()] = std::move(*it);
     unused_resources_.erase(it);
     in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
         resource->size(), resource->format());
     return resource;
   }
+  return nullptr;
+}
 
+Resource* ResourcePool::CreateResource(const gfx::Size& size,
+                                       ResourceFormat format,
+                                       const gfx::ColorSpace& color_space) {
   std::unique_ptr<PoolResource> pool_resource =
       PoolResource::Create(resource_provider_);
 
   if (use_gpu_memory_buffers_) {
     pool_resource->AllocateWithGpuMemoryBuffer(size, format, usage_,
                                                color_space);
   } else {
     pool_resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                             format, color_space);
   }
@@ skipping 10 matching lines @@
   pool_resource->set_content_id(0);
 
   Resource* resource = pool_resource.get();
   in_use_resources_[resource->id()] = std::move(pool_resource);
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
 
   return resource;
 }
 
+Resource* ResourcePool::AcquireResource(const gfx::Size& size,
+                                        ResourceFormat format,
+                                        const gfx::ColorSpace& color_space) {
+  Resource* reused_resource = ReuseResource(size, format, color_space);
+  if (reused_resource)
+    return reused_resource;
+
+  return CreateResource(size, format, color_space);
+}
+
 // Iterate over all three resource lists (unused, in-use, and busy), updating
 // the invalidation and content IDs to allow for future partial raster. The
 // first unused resource found (if any) will be returned and used for partial
 // raster directly.
 //
 // Note that this may cause us to have multiple resources with the same content
 // ID. This is not a correctness risk, as all these resources will have valid
 // invalidations can can be used safely. Note that we could improve raster
 // performance at the cost of search time if we found the resource with the
 // smallest invalidation ID to raster in to.
@@ skipping 273 matching lines @@
   for (const auto& resource : busy_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   for (const auto& entry : in_use_resources_) {
     entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   return true;
 }
 
 }  // namespace cc