Use DiscardableMemoryManager on Android.

base/memory/discardable_memory_allocation_ashmem_factory.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_ALLOCATOR_H_
-#define BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
+#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATION_ASHMEM_FACTORY_H_
+#define BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATION_ASHMEM_FACTORY_H_
 
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/memory/discardable_memory_allocation.h"
 #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 {
-
-class DiscardableMemory;
-
 namespace internal {
 
-// 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.
+// On Android/ChromeOS ashmem is used to implement discardable memory. It is
+// backed by a file (descriptor) therefore it is a limited resource. This
+// factory class (which is in fact more an 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
+// Threading: The factory 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 DiscardableMemoryAllocationAshmemFactory :
+  public DiscardableMemoryAllocation::Factory {
  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);
+  DiscardableMemoryAllocationAshmemFactory(const std::string& name,
+                                           size_t ashmem_region_size);
 
-  ~DiscardableMemoryAllocator();
+  ~DiscardableMemoryAllocationAshmemFactory();
 
-  // Note that the allocator must outlive the returned DiscardableMemory
+  // Note that the factory must outlive the returned DiscardableMemoryAllocation
   // instance.
-  scoped_ptr<DiscardableMemory> Allocate(size_t size);
+  // DiscardableMemoryAllocation::Factory:
+  virtual scoped_ptr<DiscardableMemoryAllocation> CreateLockedAllocation(
+      size_t size) OVERRIDE;
 
   // 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;
 
-  void DeleteAshmemRegion_Locked(AshmemRegion* region);
+  void DeleteAshmemRegion(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(DiscardableMemoryAllocationAshmemFactory);
 };
 
 }  // namespace internal
 }  // namespace base
 
-#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATION_ASHMEM_FACTORY_H_