Use DiscardableMemoryManager on Android.

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/trace_event.h"
@@ skipping 66 matching lines @@
   AutoLock lock(lock_);
   AllocationMap::iterator it = allocations_.Peek(allocation);
   DCHECK(it != allocations_.end());
   const AllocationInfo& info = it->second;
 
   if (info.purgable) {
     size_t bytes_purgable = info.bytes;
     DCHECK_LE(bytes_purgable, bytes_allocated_);
     bytes_allocated_ -= bytes_purgable;
     BytesAllocatedChanged();
+  } else {
+    // Note that Purge() which is called below requires the Allocation instance
+    // to be unlocked.
+    allocation->ReleaseLock();

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

It's currently up to the client to call DiscardableMemoryManager::ReleaseLock
before Unregister. Accounting will be incorrect if Unregister is called for an
allocation which a lock is currently acquired.

   }
+
+  // Purge the allocation here while the mutex is acquired to let the underlying
+  // Allocation instance not have to deal with synchronization on its own.
+  allocation->Purge();

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

I don't think we should do this here. I prefer to have Unregister simply stop
tracking the allocation and leave it up to the client to decide what to do with
it.

Maybe add a DiscardableMemoryManager::Purge(Allocation* allocation) function
instead that you can call prior to Unregister()?

+
   allocations_.Erase(it);
 }
 
 bool DiscardableMemoryManager::AcquireLock(Allocation* allocation,
                                            bool* purged) {
   AutoLock lock(lock_);
   // Note: |allocations_| is an MRU cache, and use of |Get| here updates that
   // cache.
   AllocationMap::iterator it = allocations_.Get(allocation);
   DCHECK(it != allocations_.end());
@@ skipping 119 matching lines @@
 void DiscardableMemoryManager::EnforcePolicyWithLockAcquired() {
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(memory_limit_);
 }
 
 void DiscardableMemoryManager::BytesAllocatedChanged() const {
   TRACE_COUNTER_ID1("base", "DiscardableMemoryUsage", this, bytes_allocated_);
 }
 
 }  // namespace internal
 }  // namespace base