Use DiscardableMemoryManager on Android.

base/memory/discardable_memory_ashmem.h

Index: base/memory/discardable_memory_ashmem.h
diff --git a/base/memory/discardable_memory_ashmem.h b/base/memory/discardable_memory_ashmem.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d5944185dc3bf99e38b9d94aaefc6bf967d7333
--- /dev/null
+++ b/base/memory/discardable_memory_ashmem.h
@@ -0,0 +1,53 @@
+// 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.
+
+#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_H_
+#define BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_H_
+
+#include "base/memory/discardable_memory.h"
+
+#include "base/macros.h"
+#include "base/memory/discardable_memory_manager.h"
+
+namespace base {
+namespace internal {
+
+class DiscardableAshmemChunk;
+class DiscardableMemoryAllocator;
+class DiscardableMemoryManager;
+
+class DiscardableMemoryAshmem
+    : public DiscardableMemory,
+      public internal::DiscardableMemoryManagerAllocation {
+ public:
+  explicit DiscardableMemoryAshmem(size_t size,
+                                   DiscardableMemoryAllocator* allocator,
+                                   DiscardableMemoryManager* manager);
+
+  virtual ~DiscardableMemoryAshmem();
+
+  bool Initialize();
+
+  // Overridden from DiscardableMemory:
+  virtual DiscardableMemoryLockStatus Lock() OVERRIDE;
+  virtual void Unlock() OVERRIDE;
+  virtual void* Memory() const OVERRIDE;
+
+  // Overridden from internal::DiscardableMemoryManagerAllocation:
+  virtual bool AllocateAndAcquireLock(size_t bytes) OVERRIDE;
+  virtual void ReleaseLock() OVERRIDE;
+  virtual void Purge() OVERRIDE;
+
+ private:
+  DiscardableMemoryAllocator* const allocator_;
+  DiscardableMemoryManager* const manager_;

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

nit: I don't think we typically use "const" for pointers in chromium.

[Philippe, 2014/04/28 12:23:14]

Unfortunately, yes. I saw that const is underused in Chrome whereas this usage
is very typical in Google3. I have been quite successful though so far at adding
them in Chromium (it's actually the first time a reviewer comments on this). In
addition to what the style guide says I see one clear benefit here with this
usage of const: a compilation error is generated in case the author forgets to
initialize the field. You don't get this without the const.

And of course the style guide still applies here:
"Pros: Easier for people to understand how variables are being used. Allows the
compiler to do better type checking, and, conceivably, generate better code.
Helps people convince themselves of program correctness because they know the
functions they call are limited in how they can modify your variables. Helps
people know what functions are safe to use without locks in multi-threaded
programs."

[reveman, 2014/04/28 15:39:16]

I agree that it's valuable and would prefer that it was used consistently
throughout chromium. I've been told to remove it from my patches in the past and
at the end of the day I prefer consistency. I'm perfectly fine with you keeping
this 'const' if you like. If you do, we should make sure it's consistent within
the discardable memory code at least.

[Philippe, 2014/04/28 15:53:45]

I see, thanks. I went over all our discardable memory files and AFAICS there is
no other const opportunity. The reason for that I guess is that we rarely pass
raw pointers in constructors in the discardable memory codebase.  

[willchan no longer on Chromium, 2014/04/30 06:38:21]

FWIW, I am positive on const pointers as well, but I don't comment on it in
usage. And yes, consistency is most important.

+  scoped_ptr<DiscardableAshmemChunk> ashmem_chunk_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryAshmem);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_ASHMEM_H_