Revert of base: Introduce an explicit call for reducing emulated discardable memory usage.

base/memory/discardable_memory_manager.cc

 // Copyright 2014 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 "base/memory/discardable_memory_manager.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
 namespace internal {
 
 DiscardableMemoryManager::DiscardableMemoryManager(
     size_t memory_limit,
     size_t soft_memory_limit,
+    size_t bytes_to_keep_under_moderate_pressure,
     TimeDelta hard_memory_limit_expiration_time)
     : allocations_(AllocationMap::NO_AUTO_EVICT),
       bytes_allocated_(0u),
       memory_limit_(memory_limit),
       soft_memory_limit_(soft_memory_limit),
+      bytes_to_keep_under_moderate_pressure_(
+          bytes_to_keep_under_moderate_pressure),
       hard_memory_limit_expiration_time_(hard_memory_limit_expiration_time) {
   BytesAllocatedChanged(bytes_allocated_);
 }
 
 DiscardableMemoryManager::~DiscardableMemoryManager() {
   DCHECK(allocations_.empty());
   DCHECK_EQ(0u, bytes_allocated_);
 }
 
+void DiscardableMemoryManager::RegisterMemoryPressureListener() {
+  AutoLock lock(lock_);
+  DCHECK(base::MessageLoop::current());
+  DCHECK(!memory_pressure_listener_);
+  memory_pressure_listener_.reset(new MemoryPressureListener(base::Bind(
+      &DiscardableMemoryManager::OnMemoryPressure, Unretained(this))));
+}
+
+void DiscardableMemoryManager::UnregisterMemoryPressureListener() {
+  AutoLock lock(lock_);
+  DCHECK(memory_pressure_listener_);
+  memory_pressure_listener_.reset();
+}
+
 void DiscardableMemoryManager::SetMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   memory_limit_ = bytes;
   PurgeIfNotUsedSinceTimestampUntilUsageIsWithinLimitWithLockAcquired(
       Now(), memory_limit_);
 }
 
 void DiscardableMemoryManager::SetSoftMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   soft_memory_limit_ = bytes;
 }
 
+void DiscardableMemoryManager::SetBytesToKeepUnderModeratePressure(
+    size_t bytes) {
+  AutoLock lock(lock_);
+  bytes_to_keep_under_moderate_pressure_ = bytes;
+}
+
 void DiscardableMemoryManager::SetHardMemoryLimitExpirationTime(
     TimeDelta hard_memory_limit_expiration_time) {
   AutoLock lock(lock_);
   hard_memory_limit_expiration_time_ = hard_memory_limit_expiration_time;
 }
 
 bool DiscardableMemoryManager::ReduceMemoryUsage() {
   return PurgeIfNotUsedSinceHardLimitCutoffUntilWithinSoftMemoryLimit();
 }
 
-void DiscardableMemoryManager::ReduceMemoryUsageUntilWithinLimit(size_t bytes) {
-  AutoLock lock(lock_);
-  PurgeIfNotUsedSinceTimestampUntilUsageIsWithinLimitWithLockAcquired(Now(),
-                                                                      bytes);
-}
-
 void DiscardableMemoryManager::Register(Allocation* allocation, size_t bytes) {
   AutoLock lock(lock_);
+  // A registered memory listener is currently required. This DCHECK can be
+  // moved or removed if we decide that it's useful to relax this condition.
+  // TODO(reveman): Enable this DCHECK when skia and blink are able to
+  // register memory pressure listeners. crbug.com/333907
+  // DCHECK(memory_pressure_listener_);
   DCHECK(allocations_.Peek(allocation) == allocations_.end());
   allocations_.Put(allocation, AllocationInfo(bytes));
 }
 
 void DiscardableMemoryManager::Unregister(Allocation* allocation) {
   AutoLock lock(lock_);
   AllocationMap::iterator it = allocations_.Peek(allocation);
   DCHECK(it != allocations_.end());
   const AllocationInfo& info = it->second;
 
@@ skipping 78 matching lines @@
   AutoLock lock(lock_);
   AllocationMap::const_iterator it = allocations_.Peek(allocation);
   return it != allocations_.end() && it->second.purgable;
 }
 
 size_t DiscardableMemoryManager::GetBytesAllocatedForTest() const {
   AutoLock lock(lock_);
   return bytes_allocated_;
 }
 
+void DiscardableMemoryManager::OnMemoryPressure(
+    MemoryPressureListener::MemoryPressureLevel pressure_level) {
+  switch (pressure_level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
+      PurgeUntilWithinBytesToKeepUnderModeratePressure();
+      return;
+    case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
+      PurgeAll();
+      return;
+  }
+
+  NOTREACHED();
+}
+
+void
+DiscardableMemoryManager::PurgeUntilWithinBytesToKeepUnderModeratePressure() {
+  AutoLock lock(lock_);
+
+  PurgeIfNotUsedSinceTimestampUntilUsageIsWithinLimitWithLockAcquired(
+      Now(), bytes_to_keep_under_moderate_pressure_);
+}
+
 bool DiscardableMemoryManager::
     PurgeIfNotUsedSinceHardLimitCutoffUntilWithinSoftMemoryLimit() {
   AutoLock lock(lock_);
 
   PurgeIfNotUsedSinceTimestampUntilUsageIsWithinLimitWithLockAcquired(
       Now() - hard_memory_limit_expiration_time_, soft_memory_limit_);
 
   return bytes_allocated_ <= soft_memory_limit_;
 }
 
@@ skipping 37 matching lines @@
   base::debug::SetCrashKeyValue(kDiscardableMemoryUsageKey,
                                 Uint64ToString(new_bytes_allocated));
 }
 
 TimeTicks DiscardableMemoryManager::Now() const {
   return TimeTicks::Now();
 }
 
 }  // namespace internal
 }  // namespace base