Use DiscardableMemoryManager on Android.

base/memory/discardable_memory_ashmem_allocator.h

Index: base/memory/discardable_memory_ashmem_allocator.h
diff --git a/base/memory/discardable_memory_allocator_android.h b/base/memory/discardable_memory_ashmem_allocator.h
similarity index 44%
rename from base/memory/discardable_memory_allocator_android.h
rename to base/memory/discardable_memory_ashmem_allocator.h
index eea57fb3893a827c40063dcafb520650ed010d8b..5106e1af77449816a6b90434983db3c40a09f023 100644
--- a/base/memory/discardable_memory_allocator_android.h
+++ b/base/memory/discardable_memory_ashmem_allocator.h
@@ -2,8 +2,8 @@
 // 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_ALLOCATOR_H_
-#define BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
+#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_
+#define BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_
 
 #include <string>
 
@@ -12,59 +12,82 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/lock.h"
-#include "base/threading/thread_checker.h"
 
 namespace base {
+namespace internal {
 
-class DiscardableMemory;
+class AshmemRegion;
 
-namespace internal {
+// Internal class, whose instances are returned to the client of the allocator
+// (e.g. DiscardableMemoryAshmem), that mimicks the DiscardableMemory interface.
+class BASE_EXPORT_PRIVATE DiscardableAshmemChunk {
+ public:
+  ~DiscardableAshmemChunk();
+
+  // Returns whether the memory is still resident.
+  bool Lock();
+
+  void Unlock();
+
+  void* Memory() const;
+
+ private:
+  friend class AshmemRegion;
+
+  DiscardableAshmemChunk(AshmemRegion* ashmem_region,
+                         int fd,
+                         void* address,
+                         size_t offset,
+                         size_t size);
+
+  AshmemRegion* const ashmem_region_;
+  const int fd_;
+  void* const address_;
+  const size_t offset_;
+  const size_t size_;
+  bool locked_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableAshmemChunk);
+};
 
-// On Android ashmem is used to implement discardable memory. It is backed by a
-// file (descriptor) thus is a limited resource. This allocator minimizes the
-// problem by allocating large ashmem regions internally and returning smaller
-// chunks to the client.
+// Ashmem regions are backed by a file (descriptor) therefore they are a limited
+// resource. This allocator minimizes the problem by allocating large ashmem
+// regions internally and returning smaller chunks to the client.
 // Allocated chunks are systematically aligned on a page boundary therefore this
 // allocator should not be used for small allocations.
-//
-// Threading: The allocator must be deleted on the thread it was constructed on
-// although its Allocate() method can be invoked on any thread. See
-// discardable_memory.h for DiscardableMemory's threading guarantees.
-class BASE_EXPORT_PRIVATE DiscardableMemoryAllocator {
+class BASE_EXPORT_PRIVATE DiscardableMemoryAshmemAllocator {
  public:
   // Note that |name| is only used for debugging/measurement purposes.
   // |ashmem_region_size| is the size that will be used to create the underlying
   // ashmem regions and is expected to be greater or equal than 32 MBytes.
-  DiscardableMemoryAllocator(const std::string& name,
-                             size_t ashmem_region_size);
+  DiscardableMemoryAshmemAllocator(const std::string& name,
+                                   size_t ashmem_region_size);
 
-  ~DiscardableMemoryAllocator();
+  ~DiscardableMemoryAshmemAllocator();
 
-  // Note that the allocator must outlive the returned DiscardableMemory
+  // Note that the allocator must outlive the returned DiscardableAshmemChunk
   // instance.
-  scoped_ptr<DiscardableMemory> Allocate(size_t size);
+  scoped_ptr<DiscardableAshmemChunk> Allocate(size_t size);
 
   // Returns the size of the last ashmem region which was created. This is used
   // for testing only.
   size_t last_ashmem_region_size() const;
 
  private:
-  class AshmemRegion;
-  class DiscardableAshmemChunk;
+  friend class AshmemRegion;
 
   void DeleteAshmemRegion_Locked(AshmemRegion* region);
 
-  ThreadChecker thread_checker_;
   const std::string name_;
   const size_t ashmem_region_size_;
   mutable Lock lock_;
   size_t last_ashmem_region_size_;
   ScopedVector<AshmemRegion> ashmem_regions_;
 
-  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryAllocator);
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryAshmemAllocator);
 };
 
 }  // namespace internal
 }  // namespace base
 
-#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_ALLOCATOR_H_