[Not for review] Discardable memory emulation

base/memory/discardable_memory.cc

 // Copyright (c) 2013 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 "base/memory/discardable_memory.h"
 
 #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());
 }
 
+// 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() {
+  if (s_provider)
+    s_provider->Unregister(this);
+  else
+    NOTREACHED();
+}
+
+// static
+bool DiscardableMemory::Supported() {
+  return s_provider;
+}
+
+// static
+void DiscardableMemory::SetProvider(DiscardableMemoryProvider* provider) {
+  s_provider = provider;
+}
+
+bool DiscardableMemory::InitializeAndLock(size_t size) {
+  if (s_provider)
+    return s_provider->Register(this, size);
+  NOTREACHED();
+  return false;
+}
+
+LockDiscardableMemoryStatus DiscardableMemory::Lock() {
+  if (s_provider)
+    return s_provider->Lock(this);
+  NOTREACHED();
+  return DISCARDABLE_MEMORY_FAILED;
+}
+
+void DiscardableMemory::Unlock() {
+  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() {
+  if (s_provider)
+    s_provider->PurgeForTesting();
+  else
+    NOTREACHED();
+}
+
+#else
+
 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)
-
-DiscardableMemory::~DiscardableMemory() {
-  NOTIMPLEMENTED();
-}
-
-// static
-bool DiscardableMemory::Supported() {
-  return false;
-}
-
-bool DiscardableMemory::InitializeAndLock(size_t size) {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-LockDiscardableMemoryStatus DiscardableMemory::Lock() {
-  NOTIMPLEMENTED();
-  return DISCARDABLE_MEMORY_FAILED;
-}
-
-void DiscardableMemory::Unlock() {
-  NOTIMPLEMENTED();
-}
-
-// static
-bool DiscardableMemory::PurgeForTestingSupported() {
-  return false;
-}
-
-// static
-void DiscardableMemory::PurgeForTesting() {
-  NOTIMPLEMENTED();
-}
-
 #endif  // OS_*
 
 }  // namespace base