[Experiment] purge-and-suspend

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/allocator/allocator_extension.h"
 #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 {
@@ skipping 45 matching lines @@
       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)),
       weak_ptr_factory_(this) {
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "cc::ResourcePool", task_runner_.get());
+
+  memory_pressure_listener_.reset(new base::MemoryPressureListener(
+      base::Bind(&ResourcePool::OnMemoryPressure, base::Unretained(this))));
 }
 
 ResourcePool::~ResourcePool() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   DCHECK_EQ(0u, in_use_resources_.size());
 
   while (!busy_resources_.empty()) {
     DidFinishUsingResource(PopBack(&busy_resources_));
@@ skipping 129 matching lines @@
 }
 
 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
                                           size_t max_resource_count) {
   max_memory_usage_bytes_ = max_memory_usage_bytes;
   max_resource_count_ = max_resource_count;
 
   ReduceResourceUsage();
 }
 
+void ResourcePool::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  while (!unused_resources_.empty())
+    DeleteResource(PopBack(&unused_resources_));
+  base::allocator::ReleaseFreeMemory();
+}
+
 void ResourcePool::ReduceResourceUsage() {
   while (!unused_resources_.empty()) {
     if (!ResourceUsageTooHigh())
       break;
 
     // LRU eviction pattern. Most recently used might be blocked by
     // a read lock fence but it's still better to evict the least
     // recently used as it prevents a resource that is hard to reuse
     // because of unique size from being kept around. Resources that
     // can't be locked for write might also not be truly free-able.
@@ skipping 113 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