base: Refactor DiscardableMemoryProvider to build and be tested on all platforms.

base/memory/discardable_memory_provider.cc

 // Copyright 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_provider.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
 #include "base/debug/trace_event.h"
-#include "base/lazy_instance.h"
-#include "base/memory/discardable_memory.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_info.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
-static base::LazyInstance<DiscardableMemoryProvider>::Leaky g_provider =
-    LAZY_INSTANCE_INITIALIZER;
-
-// If this is given a valid value via SetInstanceForTest, this pointer will be
-// returned by GetInstance rather than |g_provider|.
-static DiscardableMemoryProvider* g_provider_for_test = NULL;
-
 // This is admittedly pretty magical. It's approximately enough memory for two
 // 2560x1600 images.
 static const size_t kDefaultDiscardableMemoryLimit = 32 * 1024 * 1024;
 static const size_t kDefaultBytesToReclaimUnderModeratePressure =
     kDefaultDiscardableMemoryLimit / 2;
 
 }  // namespace
 
 DiscardableMemoryProvider::DiscardableMemoryProvider()
     : allocations_(AllocationMap::NO_AUTO_EVICT),
       bytes_allocated_(0),
       discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
       bytes_to_reclaim_under_moderate_pressure_(
           kDefaultBytesToReclaimUnderModeratePressure),
       memory_pressure_listener_(
-          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure)) {
+          base::Bind(&DiscardableMemoryProvider::NotifyMemoryPressure,
+                     Unretained(this))) {
 }
 
 DiscardableMemoryProvider::~DiscardableMemoryProvider() {
   DCHECK(allocations_.empty());
   DCHECK_EQ(0u, bytes_allocated_);
 }
 
-// static
-DiscardableMemoryProvider* DiscardableMemoryProvider::GetInstance() {
-  if (g_provider_for_test)
-    return g_provider_for_test;
-  return g_provider.Pointer();
-}
-
-// static
-void DiscardableMemoryProvider::SetInstanceForTest(
-    DiscardableMemoryProvider* provider) {
-  g_provider_for_test = provider;
-}
-
-// static
 void DiscardableMemoryProvider::NotifyMemoryPressure(
     MemoryPressureListener::MemoryPressureLevel pressure_level) {
   switch (pressure_level) {
     case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
-      DiscardableMemoryProvider::GetInstance()->Purge();
+      Purge();
       return;
     case MemoryPressureListener::MEMORY_PRESSURE_CRITICAL:
-      DiscardableMemoryProvider::GetInstance()->PurgeAll();
+      PurgeAll();
       return;
   }
 
   NOTREACHED();
 }
 
 void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   discardable_memory_limit_ = bytes;
   EnforcePolicyWithLockAcquired();
@@ skipping 145 matching lines @@
     it->second.memory = NULL;
   }
 }
 
 void DiscardableMemoryProvider::EnforcePolicyWithLockAcquired() {
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(discardable_memory_limit_);
 }
 
 }  // namespace internal
 }  // namespace base