Revert of cc::ResourcePool - Re-use larger resources for smaller requests

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>
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 
 using base::trace_event::MemoryAllocatorDump;
 using base::trace_event::MemoryDumpLevelOfDetail;
 
 namespace cc {
-namespace {
-bool ResourceMeetsSizeRequirements(const gfx::Size& requested_size,
-                                   const gfx::Size& actual_size) {
-  const float kReuseThreshold = 2.0f;
-
-  // Allocating new resources is expensive, and we'd like to re-use our
-  // existing ones within reason. Allow a larger resource to be used for a
-  // smaller request.
-  if (actual_size.width() < requested_size.width() ||
-      actual_size.height() < requested_size.height())
-    return false;
-
-  // GetArea will crash on overflow, however all sizes in use are tile sizes.
-  // These are capped at ResourceProvider::max_texture_size(), and will not
-  // overflow.
-  float actual_area = actual_size.GetArea();
-  float requested_area = requested_size.GetArea();
-  // Don't use a resource that is more than |kReuseThreshold| times the
-  // requested pixel area, as we want to free unnecessarily large resources.
-  if (actual_area / requested_area > kReuseThreshold)
-    return false;
-
-  return true;
-}
-
-}  // namespace
-
 base::TimeDelta ResourcePool::kDefaultExpirationDelay =
-    base::TimeDelta::FromSeconds(5);
+    base::TimeDelta::FromSeconds(1);
 
 void ResourcePool::PoolResource::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd,
     const ResourceProvider* resource_provider,
     bool is_free) const {
   // Resource IDs are not process-unique, so log with the ResourceProvider's
   // unique id.
   std::string parent_node =
       base::StringPrintf("cc/resource_memory/provider_%d/resource_%d",
                          resource_provider->tracing_id(), id());
@@ skipping 73 matching lines @@
   // 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 (!ResourceMeetsSizeRequirements(size, resource->size()))
+    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;
@@ skipping 346 matching lines @@
   }
   return true;
 }
 
 void ResourcePool::OnPurgeMemory() {
   // Release all resources, regardless of how recently they were used.
   EvictResourcesNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
 }
 
 }  // namespace cc