Revert 244229 "base: Fix registering of memory pressure listener..."

trunk/src/base/memory/discardable_memory_provider.cc

 // Copyright 2013 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_provider.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
 #include "base/debug/trace_event.h"
@@ skipping 11 matching lines @@
 static const size_t kDefaultBytesToReclaimUnderModeratePressure =
     kDefaultDiscardableMemoryLimit / 2;
 
 }  // namespace
 
 DiscardableMemoryProvider::DiscardableMemoryProvider()
     : allocations_(AllocationMap::NO_AUTO_EVICT),
       bytes_allocated_(0),
       discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
       bytes_to_reclaim_under_moderate_pressure_(
-          kDefaultBytesToReclaimUnderModeratePressure) {
+          kDefaultBytesToReclaimUnderModeratePressure),
+      memory_pressure_listener_(
+          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure,
+                     Unretained(this))) {
 }
 
 DiscardableMemoryProvider::~DiscardableMemoryProvider() {
   DCHECK(allocations_.empty());
   DCHECK_EQ(0u, bytes_allocated_);
 }
 
-void DiscardableMemoryProvider::RegisterMemoryPressureListener() {
-  AutoLock lock(lock_);
-  DCHECK(base::MessageLoop::current());
-  DCHECK(!memory_pressure_listener_);
-  memory_pressure_listener_.reset(
-      new MemoryPressureListener(
-          base::Bind(&DiscardableMemoryProvider::OnMemoryPressure,
-                     Unretained(this))));
-}
+void DiscardableMemoryProvider::NotifyMemoryPressure(
+    MemoryPressureListener::MemoryPressureLevel pressure_level) {
+  switch (pressure_level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
+      Purge();
+      return;
+    case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
+      PurgeAll();
+      return;
+  }
 
-void DiscardableMemoryProvider::UnregisterMemoryPressureListener() {
-  AutoLock lock(lock_);
-  DCHECK(memory_pressure_listener_);
-  memory_pressure_listener_.reset();
+  NOTREACHED();
 }
 
 void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   discardable_memory_limit_ = bytes;
   EnforcePolicyWithLockAcquired();
 }
 
 void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
     size_t bytes) {
   AutoLock lock(lock_);
   bytes_to_reclaim_under_moderate_pressure_ = bytes;
 }
 
 void DiscardableMemoryProvider::Register(
     const DiscardableMemory* discardable, 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.
-  DCHECK(memory_pressure_listener_);
   DCHECK(allocations_.Peek(discardable) == allocations_.end());
   allocations_.Put(discardable, Allocation(bytes));
 }
 
 void DiscardableMemoryProvider::Unregister(
     const DiscardableMemory* discardable) {
   AutoLock lock(lock_);
   AllocationMap::iterator it = allocations_.Peek(discardable);
   if (it == allocations_.end())
     return;
@@ skipping 80 matching lines @@
   AutoLock lock(lock_);
   AllocationMap::const_iterator it = allocations_.Peek(discardable);
   return it != allocations_.end() && it->second.memory;
 }
 
 size_t DiscardableMemoryProvider::GetBytesAllocatedForTest() const {
   AutoLock lock(lock_);
   return bytes_allocated_;
 }
 
-void DiscardableMemoryProvider::OnMemoryPressure(
-    MemoryPressureListener::MemoryPressureLevel pressure_level) {
-  switch (pressure_level) {
-    case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
-      Purge();
-      return;
-    case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
-      PurgeAll();
-      return;
-  }
-
-  NOTREACHED();
-}
-
 void DiscardableMemoryProvider::Purge() {
   AutoLock lock(lock_);
 
   if (bytes_to_reclaim_under_moderate_pressure_ == 0)
     return;
 
   size_t limit = 0;
   if (bytes_to_reclaim_under_moderate_pressure_ < bytes_allocated_)
     limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
 
@@ skipping 24 matching lines @@
     it->second.memory = NULL;
   }
 }
 
 void DiscardableMemoryProvider::EnforcePolicyWithLockAcquired() {
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(discardable_memory_limit_);
 }
 
 }  // namespace internal
 }  // namespace base