Add DiscardableMemoryAllocator to work around FD limit issue.

base/memory/discardable_memory_allocator_android.h

Index: base/memory/discardable_memory_allocator_android.h
diff --git a/base/memory/discardable_memory_allocator_android.h b/base/memory/discardable_memory_allocator_android.h
new file mode 100644
index 0000000000000000000000000000000000000000..7991656cff600d418871f23992e85b1dcdfbf585
--- /dev/null
+++ b/base/memory/discardable_memory_allocator_android.h
@@ -0,0 +1,65 @@
+// 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_
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/basictypes.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.
+// 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 {
+ public:
+  // Exposed for testing.
+  enum {
+    kMinAshmemRegionSize = 32 * 1024 * 1024,

[willchan no longer on Chromium, 2013/11/28 06:16:37]

When the allocation size is larger than this, is there any benefit to using
DiscardableMemoryAllocator? Since it eagerly frees memory to prevent memory
pressure, then anything larger than this constant will be immediately freed. I
see you have a test for this, and it's not obvious to me why you wouldn't just
create a DiscardableMemoryAndroidSimple for it instead.

[Philippe, 2013/11/28 16:42:53]

Yeah, you're right. I slightly modified the heuristic in
discardable_memory_android.cc to take this into account (note that I might also
tune the heuristic a little more later on for e.g. small allocations). I kept
the unit test though since in some cases we might have to fallback to the
allocator if FD usage gets really too high.

+  };
+
+  // Note that |name| is only used for debugging/measurement purposes.
+  explicit DiscardableMemoryAllocator(const std::string& name);
+  ~DiscardableMemoryAllocator();
+
+  // Note that the allocator must outlive the returned DiscardableMemory
+  // instance.
+  scoped_ptr<DiscardableMemory> Allocate(size_t size);
+
+ private:
+  class AshmemRegion;
+  class DiscardableAshmemChunk;
+
+  void DeleteAshmemRegion_Locked(AshmemRegion* region);
+
+  base::ThreadChecker thread_checker_;
+  const std::string name_;
+  base::Lock lock_;
+  ScopedVector<AshmemRegion> ashmem_regions_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryAllocator);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ALLOCATOR_H_