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_

[reveman, 2014/03/20 19:33:44]

Let's make sure the type is always the last suffix of the file (and class name):
discardable_memory_allocation_factory_ashmem.h

Maybe it was a mistake to have the factory interface be a subclass of
allocation.

[Philippe, 2014/03/21 10:17:44]

Yeah. I think it's still ok though to have the Factory as a nested class.

 
 #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

[reveman, 2014/03/20 19:33:44]

I don't think the Android, ChromeOS or any other specific platform should be
mentioned here.

[Philippe, 2014/03/21 10:17:44]

Done.

+// 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
-// although its Allocate() method can be invoked on any thread. See
-// discardable_memory.h for DiscardableMemory's threading guarantees.
-class BASE_EXPORT_PRIVATE DiscardableMemoryAllocator {
+// WARNING: this class is not thread-safe!
+class BASE_EXPORT_PRIVATE DiscardableMemoryAllocationAshmemFactory :

[reveman, 2014/03/20 19:33:44]

I much prefer DiscardableMemoryAllocationFactoryAshmem

[Philippe, 2014/03/21 10:17:44]

Yeah, done.

+    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();
+  virtual ~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_