Change ResourcePool reuse to have looser size constraints.

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::ReuseResource(const gfx::Size& size,
+Resource* ResourcePool::ReuseResource(const gfx::Size& min_size,
+                                      const gfx::Size& max_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.
+  ResourceDeque::iterator best_match = unused_resources_.end();
+  int64_t best_distance = std::numeric_limits<std::int64_t>::max();
   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;
+    if (resource->size() == min_size) {
+      best_match = it;
+      break;
+    }
 
-    // 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;
+    int32_t width = resource->size().width();
+    int32_t height = resource->size().height();
+    if (width < min_size.width() || width > max_size.width())
+      continue;
+    if (height < min_size.height() || height > max_size.height())
+      continue;
+
+    int64_t distance = width * height;
+    if (distance < best_distance) {
+      best_distance = distance;
+      best_match = it;
+    }
   }
-  return nullptr;
+
+  if (best_match == unused_resources_.end())
+    return nullptr;
+
+  ScopedResource* resource = best_match->get();
+  DCHECK(resource_provider_->CanLockForWrite(resource->id()));
+
+  // Transfer resource to |in_use_resources_|.
+  in_use_resources_[resource->id()] = std::move(*best_match);
+  unused_resources_.erase(best_match);
+  in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
+      resource->size(), resource->format());
+  return resource;
 }
 
 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_,
@@ skipping 18 matching lines @@
   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);
+  Resource* reused_resource = ReuseResource(size, 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.
@@ skipping 279 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