[Not for review] Discardable memory emulation

base/memory/discardable_memory.cc

Index: base/memory/discardable_memory.cc
diff --git a/base/memory/discardable_memory.cc b/base/memory/discardable_memory.cc
index 33f9e19cdeee523f7b99a53a8452ef23f0f569f0..df6034227164d6c53081099cbde79f0a3e9bfd2e 100644
--- a/base/memory/discardable_memory.cc
+++ b/base/memory/discardable_memory.cc
@@ -6,59 +6,97 @@
 
 #include "base/logging.h"
 
+#include <stdio.h>
+
 namespace base {
 
 DiscardableMemory::DiscardableMemory()
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
     : memory_(NULL),
       size_(0),
       is_locked_(false)
 #if defined(OS_ANDROID)
       , fd_(-1)
 #endif  // OS_ANDROID
+#endif  // OS_ANDROID || OS_MACOSX
       {
   DCHECK(Supported());
 }
 
-void* DiscardableMemory::Memory() const {
-  DCHECK(is_locked_);
-  return memory_;
-}
-
 // Stub implementations for platforms that don't support discardable memory.
 
 #if !defined(OS_ANDROID) && !defined(OS_MACOSX)
 
+namespace {
+static DiscardableMemoryProvider* s_provider = NULL;

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

Who owns the s_provider?  I see it being set, but not reset.

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

The render thread impl. It now resets it in its destructor.

+}  // namespace
+
 DiscardableMemory::~DiscardableMemory() {
-  NOTIMPLEMENTED();
+  if (s_provider)
+    s_provider->Unregister(this);
+  else
+    NOTREACHED();
 }
 
 // static
 bool DiscardableMemory::Supported() {
-  return false;
+  return s_provider;
+}
+
+// static
+void DiscardableMemory::SetProvider(DiscardableMemoryProvider* provider) {
+  s_provider = provider;
 }
 
 bool DiscardableMemory::InitializeAndLock(size_t size) {
-  NOTIMPLEMENTED();
+  if (s_provider)
+    return s_provider->Register(this, size);
+  NOTREACHED();
   return false;
 }
 
 LockDiscardableMemoryStatus DiscardableMemory::Lock() {
-  NOTIMPLEMENTED();
+  if (s_provider)
+    return s_provider->Lock(this);
+  NOTREACHED();
   return DISCARDABLE_MEMORY_FAILED;
 }
 
 void DiscardableMemory::Unlock() {
-  NOTIMPLEMENTED();
+  if (s_provider)
+    s_provider->Unlock(this);
+  else
+    NOTREACHED();
+}
+
+void* DiscardableMemory::Memory() const {
+  if (s_provider)
+    return s_provider->Memory(this);
+  NOTREACHED();
+  return NULL;
 }
 
 // static
 bool DiscardableMemory::PurgeForTestingSupported() {
+  if (s_provider)
+    return s_provider->PurgeForTestingSupported();
+  NOTREACHED();
   return false;
 }
 
 // static
 void DiscardableMemory::PurgeForTesting() {
-  NOTIMPLEMENTED();
+  if (s_provider)
+    s_provider->PurgeForTesting();
+  else
+    NOTREACHED();
+}
+
+#else
+
+void* DiscardableMemory::Memory() const {
+  DCHECK(is_locked_);
+  return memory_;
 }
 
 #endif  // OS_*