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

base/memory/discardable_memory_provider.h

 // 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_
 #define BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_
 
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
@@ skipping 28 matching lines @@
 // memory -- if the pressure is moderate -- or all discardable memory
 // if the pressure is critical.
 //
 // NB - this class is an implementation detail. It has been exposed for testing
 // purposes. You should not need to use this class directly.
 class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
  public:
   DiscardableMemoryProvider();
   ~DiscardableMemoryProvider();
 
+  // Call this to register memory pressure listener. Must be called on a
+  // thread with a MessageLoop current.
+  void RegisterMemoryPressureListener();
+
+  // Call this to unregister memory pressure listener.
+  void UnregisterMemoryPressureListener();
+
   // The maximum number of bytes of discardable memory that may be allocated
   // before we force a purge. If this amount is zero, it is interpreted as
   // having no limit at all.
   void SetDiscardableMemoryLimit(size_t bytes);
 
   // Sets the amount of memory to reclaim when we're under moderate pressure.
   void SetBytesToReclaimUnderModeratePressure(size_t bytes);
 
   // Adds the given discardable memory to the provider's collection.
   void Register(const DiscardableMemory* discardable, size_t bytes);
@@ skipping 33 matching lines @@
        : bytes(bytes),
          memory(NULL) {
    }
 
     size_t bytes;
     uint8* memory;
   };
   typedef HashingMRUCache<const DiscardableMemory*, Allocation> AllocationMap;
 
   // This can be called as a hint that the system is under memory pressure.
-  void NotifyMemoryPressure(
+  void OnMemoryPressure(
       MemoryPressureListener::MemoryPressureLevel pressure_level);
 
   // Purges |bytes_to_reclaim_under_moderate_pressure_| bytes of
   // discardable memory.
   void Purge();
 
   // Purges least recently used memory until usage is less or equal to |limit|.
   // Caller must acquire |lock_| prior to calling this function.
   void PurgeLRUWithLockAcquiredUntilUsageIsWithin(size_t limit);
 
@@ skipping 12 matching lines @@
 
   // The maximum number of bytes of discardable memory that may be allocated
   // before we assume moderate memory pressure.
   size_t discardable_memory_limit_;
 
   // Under moderate memory pressure, we will purge this amount of memory.
   size_t bytes_to_reclaim_under_moderate_pressure_;
 
   // Allows us to be respond when the system reports that it is under memory
   // pressure.
-  MemoryPressureListener memory_pressure_listener_;
+  scoped_ptr<MemoryPressureListener> memory_pressure_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryProvider);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_