Re-land: base: Fix registering of memory pressure listeners used when emulating discardable memory.

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),
-      memory_pressure_listener_(
-          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure,
-                     Unretained(this))) {
+          kDefaultBytesToReclaimUnderModeratePressure) {
 }
 
 DiscardableMemoryProvider::~DiscardableMemoryProvider() {
   DCHECK(allocations_.empty());
   DCHECK_EQ(0u, bytes_allocated_);
 }
 
-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::RegisterMemoryPressureListener() {
+  AutoLock lock(lock_);
+  DCHECK(base::MessageLoop::current());
+  DCHECK(!memory_pressure_listener_);
+  memory_pressure_listener_.reset(
+      new MemoryPressureListener(
+          base::Bind(&DiscardableMemoryProvider::OnMemoryPressure,
+                     Unretained(this))));
+}
 
-  NOTREACHED();
+void DiscardableMemoryProvider::UnregisterMemoryPressureListener() {
+  AutoLock lock(lock_);
+  DCHECK(memory_pressure_listener_);
+  memory_pressure_listener_.reset();
 }
 
 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.
+  // TODO(reveman): Enable this DCHECK when skia and blink are able to
+  // register memory pressure listeners. crbug.com/333907
+  // DCHECK(memory_pressure_listener_);

[reveman, 2014/01/13 18:22:28]

Disabled this DCHECK for now as it's causing webkit_unit_tests to fail. I will
re-enable this as soon as I've added the necessary APIs to blink and skia that
allow us to enforce this everywhere.

   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