Use DiscardableMemoryManager on Android.

base/memory/discardable_memory_manager.h

 // 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_
 #define BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_
 
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/synchronization/lock.h"
 
 namespace base {
 namespace internal {
 
 // This interface is used by the DiscardableMemoryManager class to provide some
 // level of userspace control over discardable memory allocations.
+//
+// Thread-safety: The methods below are called while the manager's mutex is
+// acquired. This means that subclasses don't need to deal with synchronization
+// as long as they correctly go through the manager's methods (e.g.
+// AcuireLock(), ReleaseLock()...).

[reveman, 2014/04/26 00:13:37]

It's really the usage by the manager rather than the interface itself that
provides this guarantee. How about we move this comment to the Manager below?
Maybe next to the Register() function. ie. "allocations registered with the
manager will never be used concurrently.."

 class DiscardableMemoryManagerAllocation {
  public:
   // Allocate and acquire a lock that prevents the allocation from being purged
   // by the system. Returns true if memory was previously allocated and is still
   // resident.
   virtual bool AllocateAndAcquireLock(size_t bytes) = 0;
 
   // Release a previously acquired lock on the allocation so that it can be
   // purged by the system.
   virtual void ReleaseLock() = 0;
@@ skipping 134 matching lines @@
   // pressure.
   scoped_ptr<MemoryPressureListener> memory_pressure_listener_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryManager);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_