content: Release all free discardable memory when idle.

content/common/discardable_shared_memory_heap_unittest.cc

Index: content/common/discardable_shared_memory_heap_unittest.cc
diff --git a/content/common/discardable_shared_memory_heap_unittest.cc b/content/common/discardable_shared_memory_heap_unittest.cc
index a13604f025ba16147d441a2650be37f50e830e01..20b38bf2a7ef25cd53ea088e4e1d01ef027ede9f 100644
--- a/content/common/discardable_shared_memory_heap_unittest.cc
+++ b/content/common/discardable_shared_memory_heap_unittest.cc
@@ -11,12 +11,16 @@
 namespace content {
 namespace {
 
-class DiscardableSharedMemoryHeapTest : public testing::Test {};
-
-TEST_F(DiscardableSharedMemoryHeapTest, Basic) {
+TEST(DiscardableSharedMemoryHeapTest, Basic) {
   size_t block_size = base::GetPageSize();
   DiscardableSharedMemoryHeap heap(block_size);
 
+  // Initial size should be 0.
+  EXPECT_EQ(0u, heap.GetSize());
+
+  // Initial free list size should be 0.
+  EXPECT_EQ(0u, heap.GetFreeListSize());
+
   // Free list is initially empty.
   EXPECT_FALSE(heap.SearchFreeList(1));
 
@@ -29,7 +33,13 @@ TEST_F(DiscardableSharedMemoryHeapTest, Basic) {
 
   // Create new span for memory.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(
-      heap.Grow(memory.Pass(), memory_size));
+      heap.Grow(memory.Pass()));
+
+  // Size should match |memory_size|.
+  EXPECT_EQ(memory_size, heap.GetSize());
+
+  // Free list size should still be 0.
+  EXPECT_EQ(0u, heap.GetFreeListSize());
 
   // Free list should still be empty as |new_span| is currently in use.
   EXPECT_FALSE(heap.SearchFreeList(1));
@@ -37,6 +47,9 @@ TEST_F(DiscardableSharedMemoryHeapTest, Basic) {
   // Done using |new_span|. Merge it into the free list.
   heap.MergeIntoFreeList(new_span.Pass());
 
+  // Free list size should now match |memory_size|.
+  EXPECT_EQ(memory_size, heap.GetFreeListSize());
+
   // Free list should not contain a span that is larger than kBlocks.
   EXPECT_FALSE(heap.SearchFreeList(kBlocks + 1));
 
@@ -52,7 +65,7 @@ TEST_F(DiscardableSharedMemoryHeapTest, Basic) {
   heap.MergeIntoFreeList(span.Pass());
 }
 
-TEST_F(DiscardableSharedMemoryHeapTest, SplitAndMerge) {
+TEST(DiscardableSharedMemoryHeapTest, SplitAndMerge) {
   size_t block_size = base::GetPageSize();
   DiscardableSharedMemoryHeap heap(block_size);
 
@@ -63,7 +76,7 @@ TEST_F(DiscardableSharedMemoryHeapTest, SplitAndMerge) {
       new base::DiscardableSharedMemory);
   ASSERT_TRUE(memory->CreateAndMap(memory_size));
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(
-      heap.Grow(memory.Pass(), memory_size));
+      heap.Grow(memory.Pass()));
 
   // Split span into two.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
@@ -105,7 +118,7 @@ TEST_F(DiscardableSharedMemoryHeapTest, SplitAndMerge) {
   heap.MergeIntoFreeList(large_span.Pass());
 }
 
-TEST_F(DiscardableSharedMemoryHeapTest, MergeSingleBlockSpan) {
+TEST(DiscardableSharedMemoryHeapTest, MergeSingleBlockSpan) {
   size_t block_size = base::GetPageSize();
   DiscardableSharedMemoryHeap heap(block_size);
 
@@ -116,7 +129,7 @@ TEST_F(DiscardableSharedMemoryHeapTest, MergeSingleBlockSpan) {
       new base::DiscardableSharedMemory);
   ASSERT_TRUE(memory->CreateAndMap(memory_size));
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(
-      heap.Grow(memory.Pass(), memory_size));
+      heap.Grow(memory.Pass()));
 
   // Split span into two.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
@@ -130,14 +143,14 @@ TEST_F(DiscardableSharedMemoryHeapTest, MergeSingleBlockSpan) {
   heap.MergeIntoFreeList(leftover.Pass());
 }
 
-TEST_F(DiscardableSharedMemoryHeapTest, Grow) {
+TEST(DiscardableSharedMemoryHeapTest, Grow) {
   size_t block_size = base::GetPageSize();
   DiscardableSharedMemoryHeap heap(block_size);
 
   scoped_ptr<base::DiscardableSharedMemory> memory1(
       new base::DiscardableSharedMemory);
   ASSERT_TRUE(memory1->CreateAndMap(block_size));
-  heap.MergeIntoFreeList(heap.Grow(memory1.Pass(), block_size).Pass());
+  heap.MergeIntoFreeList(heap.Grow(memory1.Pass()).Pass());
 
   // Remove a span from free list.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span1 = heap.SearchFreeList(1);
@@ -150,7 +163,7 @@ TEST_F(DiscardableSharedMemoryHeapTest, Grow) {
   scoped_ptr<base::DiscardableSharedMemory> memory2(
       new base::DiscardableSharedMemory);
   ASSERT_TRUE(memory2->CreateAndMap(block_size));
-  heap.MergeIntoFreeList(heap.Grow(memory2.Pass(), block_size).Pass());
+  heap.MergeIntoFreeList(heap.Grow(memory2.Pass()).Pass());
 
   // Memory should now be available.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span2 = heap.SearchFreeList(1);
@@ -161,15 +174,39 @@ TEST_F(DiscardableSharedMemoryHeapTest, Grow) {
   heap.MergeIntoFreeList(span2.Pass());
 }
 
-TEST_F(DiscardableSharedMemoryHeapTest, ReleaseFreeMemory) {
+TEST(DiscardableSharedMemoryHeapTest, ReleaseFreeMemory) {
   size_t block_size = base::GetPageSize();
   DiscardableSharedMemoryHeap heap(block_size);
 
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory);
   ASSERT_TRUE(memory->CreateAndMap(block_size));
-  scoped_ptr<DiscardableSharedMemoryHeap::Span> span =
-      heap.Grow(memory.Pass(), block_size);
+  scoped_ptr<DiscardableSharedMemoryHeap::Span> span = heap.Grow(memory.Pass());
+
+  // Free list should be empty.
+  EXPECT_EQ(0u, heap.GetFreeListSize());
+
+  heap.ReleaseFreeMemory();
+
+  // Size should still match |block_size|.
+  EXPECT_EQ(block_size, heap.GetSize());
+
+  heap.MergeIntoFreeList(span.Pass());
+  heap.ReleaseFreeMemory();
+
+  // Memory should have been released.
+  EXPECT_EQ(0u, heap.GetSize());
+  EXPECT_EQ(0u, heap.GetFreeListSize());
+}
+
+TEST(DiscardableSharedMemoryHeapTest, ReleasePurgedMemory) {
+  size_t block_size = base::GetPageSize();
+  DiscardableSharedMemoryHeap heap(block_size);
+
+  scoped_ptr<base::DiscardableSharedMemory> memory(
+      new base::DiscardableSharedMemory);
+  ASSERT_TRUE(memory->CreateAndMap(block_size));
+  scoped_ptr<DiscardableSharedMemoryHeap::Span> span = heap.Grow(memory.Pass());
 
   // Unlock memory so it can be purged.
   span->shared_memory()->Unlock(0, 0);
@@ -177,10 +214,13 @@ TEST_F(DiscardableSharedMemoryHeapTest, ReleaseFreeMemory) {
   // Purge and release shared memory.
   bool rv = span->shared_memory()->Purge(base::Time::Now());
   EXPECT_TRUE(rv);
-  heap.ReleaseFreeMemory();
+  heap.ReleasePurgedMemory();
 
   // Shared memory backing for |span| should be gone.
   EXPECT_FALSE(span->shared_memory());
+
+  // Size should be 0.
+  EXPECT_EQ(0u, heap.GetSize());
 }
 
 }  // namespace