[Experiment] purge-and-suspend

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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/tiles/software_image_decode_controller.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 
+#include "base/allocator/allocator_extension.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_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/debug/devtools_instrumentation.h"
 #include "cc/raster/tile_task.h"
@@ skipping 124 matching lines @@
       at_raster_decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
       locked_images_budget_(locked_memory_limit_bytes),
       format_(format) {
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
         this, "cc::SoftwareImageDecodeController",
         base::ThreadTaskRunnerHandle::Get());
   }
+  memory_pressure_listener_.reset(new base::MemoryPressureListener(
+      base::Bind(&SoftwareImageDecodeController::OnMemoryPressure,
+                 base::Unretained(this))));
 }
 
 SoftwareImageDecodeController::~SoftwareImageDecodeController() {
   DCHECK_EQ(0u, decoded_images_ref_counts_.size());
   DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
 
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
@@ skipping 526 matching lines @@
   base::AutoLock lock(lock_);
 
   // Dump each of our caches.
   DumpImageMemoryForCache(decoded_images_, "cached", pmd);
   DumpImageMemoryForCache(at_raster_decoded_images_, "at_raster", pmd);
 
   // Memory dump can't fail, always return true.
   return true;
 }
 
+void SoftwareImageDecodeController::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  decoded_images_.Clear();
+  at_raster_decoded_images_.Clear();
+  base::allocator::ReleaseFreeMemory();
+}
+
 void SoftwareImageDecodeController::DumpImageMemoryForCache(
     const ImageMRUCache& cache,
     const char* cache_name,
     base::trace_event::ProcessMemoryDump* pmd) const {
   lock_.AssertAcquired();
 
   for (const auto& image_pair : cache) {
     std::string dump_name = base::StringPrintf(
         "cc/image_memory/controller_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
         reinterpret_cast<uintptr_t>(this), cache_name,
@@ skipping 258 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc