Refactor DiscardableMemory for the upcoming DiscardableMemoryAllocator.

base/memory/discardable_memory_unittest.cc

Index: base/memory/discardable_memory_unittest.cc
diff --git a/base/memory/discardable_memory_unittest.cc b/base/memory/discardable_memory_unittest.cc
index 60d35820fbd489a2fea3c9d9af70eb6195a5df0a..55381fd3d94ceb50a83ef83a3ab3b3ce35e388ff 100644
--- a/base/memory/discardable_memory_unittest.cc
+++ b/base/memory/discardable_memory_unittest.cc
@@ -7,36 +7,36 @@
 
 namespace base {
 
+const size_t kSize = 1024;
+
 #if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Test Lock() and Unlock() functionalities.
 TEST(DiscardableMemoryTest, LockAndUnLock) {
   ASSERT_TRUE(DiscardableMemory::Supported());
 
-  const size_t size = 1024;
-
-  DiscardableMemory memory;
-  ASSERT_TRUE(memory.InitializeAndLock(size));
-  void* addr = memory.Memory();
+  const scoped_ptr<DiscardableMemory> memory(
+      DiscardableMemory::CreateLockedMemory(kSize));
+  ASSERT_TRUE(memory);
+  void* addr = memory->Memory();
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
-  memory.Unlock();
+  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_SUCCESS, memory.Lock());
-  addr = memory.Memory();
+  EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, memory->Lock());
+  addr = memory->Memory();
   ASSERT_NE(static_cast<void*>(NULL), addr);
 
-  memory.Unlock();
+  memory->Unlock();
 }
 
 // Test delete a discardable memory while it is locked.
 TEST(DiscardableMemoryTest, DeleteWhileLocked) {
   ASSERT_TRUE(DiscardableMemory::Supported());
 
-  const size_t size = 1024;
-
-  DiscardableMemory memory;
-  ASSERT_TRUE(memory.InitializeAndLock(size));
+  const scoped_ptr<DiscardableMemory> memory(
+      DiscardableMemory::CreateLockedMemory(kSize));
+  ASSERT_TRUE(memory);
 }
 
 #if defined(OS_MACOSX)
@@ -45,17 +45,26 @@ TEST(DiscardableMemoryTest, Purge) {
   ASSERT_TRUE(DiscardableMemory::Supported());
   ASSERT_TRUE(DiscardableMemory::PurgeForTestingSupported());
 
-  const size_t size = 1024;
-
-  DiscardableMemory memory;
-  ASSERT_TRUE(memory.InitializeAndLock(size));
-  memory.Unlock();
+  const scoped_ptr<DiscardableMemory> memory(
+      DiscardableMemory::CreateLockedMemory(kSize));
+  ASSERT_TRUE(memory);
+  memory->Unlock();
 
   DiscardableMemory::PurgeForTesting();
-  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, memory.Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, memory->Lock());
 }
 #endif  // OS_MACOSX
 
+#if !defined(OS_ANDROID)  // Death tests are not supported with Android APKs.
+TEST(DiscardableMemoryTest, UnlockedMemoryAccessCrashesInDebugMode) {

[Avi (use Gerrit), 2013/10/17 18:00:27]

Actually, can we ifdef this whole test out if we're not running in debug mode?

[Philippe, 2013/10/18 08:25:21]

Yeah definitely. I used to have this but lost it after I messed up wit the
defines here.

+  const scoped_ptr<DiscardableMemory> memory(
+      DiscardableMemory::CreateLockedMemory(kSize));
+  ASSERT_TRUE(memory);
+  memory->Unlock();
+  ASSERT_DEATH({ *static_cast<int*>(memory->Memory()) = 0xdeadbeef; }, ".*");
+}
+#endif
+
 #endif  // OS_*
 
 }