Encourage IOSurface reuse for CSS filter effects.

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/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"
 
 namespace cc {
-namespace {
-
-// Delay before a resource is considered expired.
-const int kResourceExpirationDelayMs = 1000;
-
-}  // namespace
+base::TimeDelta ResourcePool::kDefaultExpirationDelay =
+    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 14 matching lines @@
 
   if (is_free) {
     dump->AddScalar("free_size",
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                     total_bytes);
   }
 }
 
 ResourcePool::ResourcePool(ResourceProvider* resource_provider,
                            base::SingleThreadTaskRunner* task_runner,
-                           bool use_gpu_memory_buffers)
+                           bool use_gpu_memory_buffers,
+                           const base::TimeDelta& expiration_delay)
     : resource_provider_(resource_provider),
       use_gpu_memory_buffers_(use_gpu_memory_buffers),
       max_memory_usage_bytes_(0),
       max_resource_count_(0),
       in_use_memory_usage_bytes_(0),
       total_memory_usage_bytes_(0),
       total_resource_count_(0),
       task_runner_(task_runner),
       evict_expired_resources_pending_(false),
-      resource_expiration_delay_(
-          base::TimeDelta::FromMilliseconds(kResourceExpirationDelayMs)),
+      resource_expiration_delay_(expiration_delay),
       weak_ptr_factory_(this) {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "cc::ResourcePool", task_runner_.get());
 }
 
 ResourcePool::~ResourcePool() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   DCHECK_EQ(0u, in_use_resources_.size());
@@ skipping 366 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