[Not for review] Discardable memory emulation

content/renderer/render_process_discardable_memory_provider.cc

Index: content/renderer/render_process_discardable_memory_provider.cc
diff --git a/content/renderer/render_process_discardable_memory_provider.cc b/content/renderer/render_process_discardable_memory_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4fe9436343624bcd4bed042c432476c1083e3e8b
--- /dev/null
+++ b/content/renderer/render_process_discardable_memory_provider.cc
@@ -0,0 +1,104 @@
+// Copyright (c) 2012 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 "content/renderer/render_process_discardable_memory_provider.h"
+
+namespace content {
+
+RenderProcessDiscardableMemoryProvider::
+    RenderProcessDiscardableMemoryProvider()
+    : visible_(false) {
+}
+
+RenderProcessDiscardableMemoryProvider::
+    ~RenderProcessDiscardableMemoryProvider() {
+  AllocationMap::iterator it = allocations_.begin();
+  for (; it != allocations_.end(); ++it)
+    if (it->second.memory != NULL)
+      free(it->second.memory);
+}
+
+void RenderProcessDiscardableMemoryProvider::RenderProcessVisibilityChanged(
+    bool visible) {
+  visible_ = visible;
+  EnforcePolicy();
+}
+
+bool RenderProcessDiscardableMemoryProvider::Register(
+    const base::DiscardableMemory* discardable, size_t size) {
+  Unregister(discardable);
+  AllocatedMemory allocation = { NULL, false, size };
+  allocation.memory = malloc(size * sizeof(char));
+  if (allocation.memory == NULL)
+    return false;
+  allocations_[discardable] = allocation;
+  return true;
+}
+
+void RenderProcessDiscardableMemoryProvider::Unregister(
+    const base::DiscardableMemory* discardable) {
+  AllocationMap::iterator it = allocations_.find(discardable);
+  if (it == allocations_.end())
+    return;

[jonathan.backer, 2013/05/29 14:02:54]

DCHECK(!it->second.locked)?

[Ian Vollick, 2013/06/06 00:21:47]

Done.

+  if (it->second.memory != NULL)
+    free(it->second.memory);
+  allocations_.erase(it);
+}
+
+base::LockDiscardableMemoryStatus RenderProcessDiscardableMemoryProvider::Lock(
+    const base::DiscardableMemory* discardable) {
+  AllocationMap::iterator it = allocations_.find(discardable);
+  if (it == allocations_.end())
+    return base::DISCARDABLE_MEMORY_FAILED;
+
+  it->second.locked = true;
+  if (it->second.memory != NULL)
+    return base::DISCARDABLE_MEMORY_SUCCESS;
+
+  it->second.memory = malloc(it->second.size * sizeof(char));
+  return base::DISCARDABLE_MEMORY_PURGED;
+}
+
+void RenderProcessDiscardableMemoryProvider::Unlock(
+    const base::DiscardableMemory* discardable) {
+  AllocationMap::iterator it = allocations_.find(discardable);
+  if (it == allocations_.end())
+    return;
+  it->second.locked = false;
+}
+
+void* RenderProcessDiscardableMemoryProvider::Memory(
+    const base::DiscardableMemory* discardable) const {
+  AllocationMap::const_iterator it = allocations_.find(discardable);
+  if (it == allocations_.end())
+    return NULL;

[jonathan.backer, 2013/05/29 14:02:54]

DCHECK(it->second.locked)?

[Ian Vollick, 2013/06/06 00:21:47]

Done.

+  return it->second.memory;
+}
+
+bool RenderProcessDiscardableMemoryProvider::PurgeForTestingSupported() const {
+  return true;
+}
+
+void RenderProcessDiscardableMemoryProvider::PurgeForTesting() {
+  Purge();
+}
+
+void RenderProcessDiscardableMemoryProvider::Purge() {
+  AllocationMap::iterator it = allocations_.begin();
+  for (; it != allocations_.end(); ++it) {
+    if (it->second.memory != NULL && !it->second.locked) {
+      free(it->second.memory);
+      it->second.memory = NULL;
+    }
+  }
+}
+
+// We could be smarter here and use a MRU scheme and memory limits. Instead,
+// we'll just purge everything when the process is no longer visible.
+void RenderProcessDiscardableMemoryProvider::EnforcePolicy() {
+  if (!visible_)
+    Purge();
+}
+
+}  // namespace content