base: Add uncached malloc based discardable memory type.

Each DiscardableMemoryMalloc instance uses a separate malloc() allocated block
of memory. It's allocated on Lock() and freed on Unlock().

This is useful to test how discardable memory clients perform in situations
when the memory pressure is high. The base class will also be used by other
discardable memory implementations as a fall-back when failing to
allocate/lock native discardable memory.

BUG=334996
TEST=base_unittests --gtest_filter=DiscardableMemoryTests*

Review URL: https://codereview.chromium.org/145643008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@250167 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 128 insertions, 9 deletions

diff --git a/base/memory/discardable_memory.cc b/base/memory/discardable_memory.cc
index 5c03a16..02fc5a7 100644
--- a/base/memory/discardable_memory.cc
+++ b/base/memory/discardable_memory.cc
@@ -16,7 +16,8 @@ const struct TypeNamePair {
 } kTypeNamePairs[] = {
   { DISCARDABLE_MEMORY_TYPE_ANDROID, "android" },
   { DISCARDABLE_MEMORY_TYPE_MAC, "mac" },
-  { DISCARDABLE_MEMORY_TYPE_EMULATED, "emulated" }
+  { DISCARDABLE_MEMORY_TYPE_EMULATED, "emulated" },
+  { DISCARDABLE_MEMORY_TYPE_MALLOC, "malloc" }
 };
 
 DiscardableMemoryType g_preferred_type = DISCARDABLE_MEMORY_TYPE_NONE;
diff --git a/base/memory/discardable_memory.h b/base/memory/discardable_memory.h
index c39d0db..53d8d0e 100644
--- a/base/memory/discardable_memory.h
+++ b/base/memory/discardable_memory.h
@@ -19,7 +19,8 @@ enum DiscardableMemoryType {
   DISCARDABLE_MEMORY_TYPE_NONE,
   DISCARDABLE_MEMORY_TYPE_ANDROID,
   DISCARDABLE_MEMORY_TYPE_MAC,
-  DISCARDABLE_MEMORY_TYPE_EMULATED
+  DISCARDABLE_MEMORY_TYPE_EMULATED,
+  DISCARDABLE_MEMORY_TYPE_MALLOC
 };
 
 enum DiscardableMemoryLockStatus {
diff --git a/base/memory/discardable_memory_android.cc b/base/memory/discardable_memory_android.cc
index 2004a36..7b1731a 100644
--- a/base/memory/discardable_memory_android.cc
+++ b/base/memory/discardable_memory_android.cc
@@ -17,6 +17,7 @@
 #include "base/logging.h"
 #include "base/memory/discardable_memory_allocator_android.h"
 #include "base/memory/discardable_memory_emulated.h"
+#include "base/memory/discardable_memory_malloc.h"
 #include "third_party/ashmem/ashmem.h"
 
 namespace base {
@@ -126,7 +127,8 @@ void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
     DISCARDABLE_MEMORY_TYPE_ANDROID,
-    DISCARDABLE_MEMORY_TYPE_EMULATED
+    DISCARDABLE_MEMORY_TYPE_EMULATED,
+    DISCARDABLE_MEMORY_TYPE_MALLOC
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));
 }
@@ -149,6 +151,14 @@ scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemoryWithType(
 
       return memory.PassAs<DiscardableMemory>();
     }
+    case DISCARDABLE_MEMORY_TYPE_MALLOC: {
+      scoped_ptr<internal::DiscardableMemoryMalloc> memory(
+          new internal::DiscardableMemoryMalloc(size));
+      if (!memory->Initialize())
+        return scoped_ptr<DiscardableMemory>();
+
+      return memory.PassAs<DiscardableMemory>();
+    }
   }
 
   NOTREACHED();
diff --git a/base/memory/discardable_memory_linux.cc b/base/memory/discardable_memory_linux.cc
index 6ae9483..e44b7c2 100644
--- a/base/memory/discardable_memory_linux.cc
+++ b/base/memory/discardable_memory_linux.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "base/memory/discardable_memory_emulated.h"
+#include "base/memory/discardable_memory_malloc.h"
 
 namespace base {
 
@@ -23,7 +24,8 @@ void DiscardableMemory::UnregisterMemoryPressureListeners() {
 void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
-    DISCARDABLE_MEMORY_TYPE_EMULATED
+    DISCARDABLE_MEMORY_TYPE_EMULATED,
+    DISCARDABLE_MEMORY_TYPE_MALLOC
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));
 }
@@ -44,6 +46,14 @@ scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemoryWithType(
 
       return memory.PassAs<DiscardableMemory>();
     }
+    case DISCARDABLE_MEMORY_TYPE_MALLOC: {
+      scoped_ptr<internal::DiscardableMemoryMalloc> memory(
+          new internal::DiscardableMemoryMalloc(size));
+      if (!memory->Initialize())
+        return scoped_ptr<DiscardableMemory>();
+
+      return memory.PassAs<DiscardableMemory>();
+    }
   }
 
   NOTREACHED();
diff --git a/base/memory/discardable_memory_mac.cc b/base/memory/discardable_memory_mac.cc
index 0c0b2a6..40a9739 100644
--- a/base/memory/discardable_memory_mac.cc
+++ b/base/memory/discardable_memory_mac.cc
@@ -11,6 +11,7 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/discardable_memory_emulated.h"
+#include "base/memory/discardable_memory_malloc.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace base {
@@ -103,7 +104,8 @@ void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
     DISCARDABLE_MEMORY_TYPE_MAC,
-    DISCARDABLE_MEMORY_TYPE_EMULATED
+    DISCARDABLE_MEMORY_TYPE_EMULATED,
+    DISCARDABLE_MEMORY_TYPE_MALLOC
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));
 }
@@ -130,6 +132,14 @@ scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemoryWithType(
 
       return memory.PassAs<DiscardableMemory>();
     }
+    case DISCARDABLE_MEMORY_TYPE_MALLOC: {
+      scoped_ptr<internal::DiscardableMemoryMalloc> memory(
+          new internal::DiscardableMemoryMalloc(size));
+      if (!memory->Initialize())
+        return scoped_ptr<DiscardableMemory>();
+
+      return memory.PassAs<DiscardableMemory>();
+    }
   }
 
   NOTREACHED();
diff --git a/base/memory/discardable_memory_malloc.cc b/base/memory/discardable_memory_malloc.cc
new file mode 100644
index 0000000..be9d157
--- /dev/null
+++ b/base/memory/discardable_memory_malloc.cc
@@ -0,0 +1,43 @@
+// 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.
+
+#include "base/memory/discardable_memory_malloc.h"
+
+#include "base/logging.h"
+
+namespace base {
+namespace internal {
+
+DiscardableMemoryMalloc::DiscardableMemoryMalloc(size_t size) : size_(size) {
+}
+
+DiscardableMemoryMalloc::~DiscardableMemoryMalloc() {
+}
+
+bool DiscardableMemoryMalloc::Initialize() {
+  return Lock() == DISCARDABLE_MEMORY_LOCK_STATUS_PURGED;
+}
+
+DiscardableMemoryLockStatus DiscardableMemoryMalloc::Lock() {
+  DCHECK(!memory_);
+
+  memory_.reset(static_cast<uint8*>(malloc(size_)));
+  if (!memory_)
+    return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
+
+  return DISCARDABLE_MEMORY_LOCK_STATUS_PURGED;
+}
+
+void DiscardableMemoryMalloc::Unlock() {
+  DCHECK(memory_);
+  memory_.reset();
+}
+
+void* DiscardableMemoryMalloc::Memory() const {
+  DCHECK(memory_);
+  return memory_.get();
+}
+
+}  // namespace internal
+}  // namespace base
diff --git a/base/memory/discardable_memory_malloc.h b/base/memory/discardable_memory_malloc.h
new file mode 100644
index 0000000..7729ce5
--- /dev/null
+++ b/base/memory/discardable_memory_malloc.h
@@ -0,0 +1,35 @@
+// 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_MALLOC_H_
+#define BASE_MEMORY_DISCARDABLE_MEMORY_MALLOC_H_
+
+#include "base/memory/discardable_memory.h"
+
+namespace base {
+namespace internal {
+
+class DiscardableMemoryMalloc : public DiscardableMemory {
+ public:
+  explicit DiscardableMemoryMalloc(size_t size);
+  virtual ~DiscardableMemoryMalloc();
+
+  bool Initialize();
+
+  // Overridden from DiscardableMemory:
+  virtual DiscardableMemoryLockStatus Lock() OVERRIDE;
+  virtual void Unlock() OVERRIDE;
+  virtual void* Memory() const OVERRIDE;
+
+ private:
+  scoped_ptr<uint8, FreeDeleter> memory_;
+  const size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryMalloc);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_MALLOC_H_
diff --git a/base/memory/discardable_memory_unittest.cc b/base/memory/discardable_memory_unittest.cc
index d4a230a..d4c2955 100644
--- a/base/memory/discardable_memory_unittest.cc
+++ b/base/memory/discardable_memory_unittest.cc
@@ -77,9 +77,8 @@ TEST_P(DiscardableMemoryTest, LockAndUnLock) {
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
   memory->Unlock();
-  // The system should have no reason to purge discardable blocks in this brief
-  // interval, though technically speaking this might flake.
-  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, memory->Lock());
+
+  EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, memory->Lock());
   addr = memory->Memory();
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
diff --git a/base/memory/discardable_memory_win.cc b/base/memory/discardable_memory_win.cc
index 6ae9483..e44b7c2 100644
--- a/base/memory/discardable_memory_win.cc
+++ b/base/memory/discardable_memory_win.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "base/memory/discardable_memory_emulated.h"
+#include "base/memory/discardable_memory_malloc.h"
 
 namespace base {
 
@@ -23,7 +24,8 @@ void DiscardableMemory::UnregisterMemoryPressureListeners() {
 void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
-    DISCARDABLE_MEMORY_TYPE_EMULATED
+    DISCARDABLE_MEMORY_TYPE_EMULATED,
+    DISCARDABLE_MEMORY_TYPE_MALLOC
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));
 }
@@ -44,6 +46,14 @@ scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemoryWithType(
 
       return memory.PassAs<DiscardableMemory>();
     }
+    case DISCARDABLE_MEMORY_TYPE_MALLOC: {
+      scoped_ptr<internal::DiscardableMemoryMalloc> memory(
+          new internal::DiscardableMemoryMalloc(size));
+      if (!memory->Initialize())
+        return scoped_ptr<DiscardableMemory>();
+
+      return memory.PassAs<DiscardableMemory>();
+    }
   }
 
   NOTREACHED();