Add a DiscardableMemoryShmemeAllocator.

mojo/services/html_viewer/discardable_memory_allocator_unittest.cc

+// Copyright 2015 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 "mojo/services/html_viewer/discardable_memory_allocator.h"
+
+#include "base/memory/discardable_memory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+const size_t kOneKilobyte = 1024;
+const size_t kAlmostOneMegabyte = 1023 * kOneKilobyte;
+const size_t kOneMegabyte = 1024 * kOneKilobyte;
+
+}  // namespace
+
+TEST(DiscardableMemoryAllocator, Basic) {

[jamesr, 2015/03/19 22:09:56]

put this in an anonymous namespace. i've had ODR violations and other weirdness
in unit test targets before and it sucks

+  scoped_ptr<base::DiscardableMemory> chunk;
+
+  {
+    html_viewer::DiscardableMemoryAllocator allocator(kOneMegabyte);

[jamesr, 2015/03/19 22:09:56]

if you wrap the whole file in

namespace html_viewer {
namespace {
...
}  // namespace
}  // namespace html_viewer

then you won't have to spell out this namespace here and still get the safety of
an anonymous namespace

+
+    // Make sure the chunk is locked when allocated. In debug mode, we will
+    // dcheck.
+    chunk = allocator.AllocateLockedDiscardableMemory(kOneKilobyte);
+    chunk->Unlock();
+
+    // Make sure we can lock a chunk.
+    EXPECT_TRUE(chunk->Lock());
+    chunk->Unlock();
+  }
+
+  // The chunk's backing should have disappeared with the allocator.
+  EXPECT_FALSE(chunk->Lock());
+}
+
+TEST(DiscardableMemoryAllocator, DiscardChunks) {
+  html_viewer::DiscardableMemoryAllocator allocator(kOneMegabyte);
+
+  scoped_ptr<base::DiscardableMemory> chunk_to_remove =
+      allocator.AllocateLockedDiscardableMemory(kAlmostOneMegabyte);
+  chunk_to_remove->Unlock();
+
+  // Allocating a second chunk should deallocate the first one due to memory
+  // pressure, since we only have one megabyte available.
+  scoped_ptr<base::DiscardableMemory> chunk_to_keep =
+      allocator.AllocateLockedDiscardableMemory(kAlmostOneMegabyte);
+
+  // Fail to get a lock because allocating the second chunk removed the first.
+  EXPECT_FALSE(chunk_to_remove->Lock());
+
+  chunk_to_keep->Unlock();
+}
+
+TEST(DiscardableMemoryAllocator, DontDiscardLiveChunks) {
+  html_viewer::DiscardableMemoryAllocator allocator(kOneMegabyte);
+
+  scoped_ptr<base::DiscardableMemory> chunk_one =
+      allocator.AllocateLockedDiscardableMemory(kAlmostOneMegabyte);
+  scoped_ptr<base::DiscardableMemory> chunk_two =
+      allocator.AllocateLockedDiscardableMemory(kAlmostOneMegabyte);
+  scoped_ptr<base::DiscardableMemory> chunk_three =
+      allocator.AllocateLockedDiscardableMemory(kAlmostOneMegabyte);
+
+  // These accesses will fail if the underlying weak ptr has been deallocated.
+  EXPECT_NE(nullptr, chunk_one->Memory());
+  EXPECT_NE(nullptr, chunk_two->Memory());
+  EXPECT_NE(nullptr, chunk_three->Memory());
+
+  chunk_one->Unlock();
+  chunk_two->Unlock();
+  chunk_three->Unlock();
+}