base: Rename DiscardableMemoryProvider to DiscardableMemoryManager.

Simple renaming in preparation for refactor that will make
this logic usable by more than "emulated" discardable memory.

BUG=327516

Review URL: https://codereview.chromium.org/204783002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@258590 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 92 insertions, 92 deletions

diff --git a/base/memory/discardable_memory_emulated.cc b/base/memory/discardable_memory_emulated.cc
index be756d6..82f887f 100644
--- a/base/memory/discardable_memory_emulated.cc
+++ b/base/memory/discardable_memory_emulated.cc
@@ -5,13 +5,13 @@
 #include "base/memory/discardable_memory_emulated.h"
 
 #include "base/lazy_instance.h"
-#include "base/memory/discardable_memory_provider.h"
+#include "base/memory/discardable_memory_manager.h"
 
 namespace base {
 
 namespace {
 
-base::LazyInstance<internal::DiscardableMemoryProvider>::Leaky g_provider =
+base::LazyInstance<internal::DiscardableMemoryManager>::Leaky g_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
@@ -20,28 +20,28 @@ namespace internal {
 
 DiscardableMemoryEmulated::DiscardableMemoryEmulated(size_t size)
     : is_locked_(false) {
-  g_provider.Pointer()->Register(this, size);
+  g_manager.Pointer()->Register(this, size);
 }
 
 DiscardableMemoryEmulated::~DiscardableMemoryEmulated() {
   if (is_locked_)
     Unlock();
-  g_provider.Pointer()->Unregister(this);
+  g_manager.Pointer()->Unregister(this);
 }
 
 // static
 void DiscardableMemoryEmulated::RegisterMemoryPressureListeners() {
-  g_provider.Pointer()->RegisterMemoryPressureListener();
+  g_manager.Pointer()->RegisterMemoryPressureListener();
 }
 
 // static
 void DiscardableMemoryEmulated::UnregisterMemoryPressureListeners() {
-  g_provider.Pointer()->UnregisterMemoryPressureListener();
+  g_manager.Pointer()->UnregisterMemoryPressureListener();
 }
 
 // static
 void DiscardableMemoryEmulated::PurgeForTesting() {
-  g_provider.Pointer()->PurgeAll();
+  g_manager.Pointer()->PurgeAll();
 }
 
 bool DiscardableMemoryEmulated::Initialize() {
@@ -52,7 +52,7 @@ DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() {
   DCHECK(!is_locked_);
 
   bool purged = false;
-  memory_ = g_provider.Pointer()->Acquire(this, &purged);
+  memory_ = g_manager.Pointer()->Acquire(this, &purged);
   if (!memory_)
     return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
@@ -63,7 +63,7 @@ DiscardableMemoryLockStatus DiscardableMemoryEmulated::Lock() {
 
 void DiscardableMemoryEmulated::Unlock() {
   DCHECK(is_locked_);
-  g_provider.Pointer()->Release(this, memory_.Pass());
+  g_manager.Pointer()->Release(this, memory_.Pass());
   is_locked_ = false;
 }
 
diff --git a/base/memory/discardable_memory_provider.cc b/base/memory/discardable_memory_manager.cc
index 5d43b448..c1b9f36 100644
--- a/base/memory/discardable_memory_provider.cc
+++ b/base/memory/discardable_memory_manager.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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/memory/discardable_memory_manager.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ -24,7 +24,7 @@ static const size_t kDefaultBytesToKeepUnderModeratePressure =
 
 }  // namespace
 
-DiscardableMemoryProvider::DiscardableMemoryProvider()
+DiscardableMemoryManager::DiscardableMemoryManager()
     : allocations_(AllocationMap::NO_AUTO_EVICT),
       bytes_allocated_(0),
       discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
@@ -32,40 +32,40 @@ DiscardableMemoryProvider::DiscardableMemoryProvider()
           kDefaultBytesToKeepUnderModeratePressure) {
 }
 
-DiscardableMemoryProvider::~DiscardableMemoryProvider() {
+DiscardableMemoryManager::~DiscardableMemoryManager() {
   DCHECK(allocations_.empty());
   DCHECK_EQ(0u, bytes_allocated_);
 }
 
-void DiscardableMemoryProvider::RegisterMemoryPressureListener() {
+void DiscardableMemoryManager::RegisterMemoryPressureListener() {
   AutoLock lock(lock_);
   DCHECK(base::MessageLoop::current());
   DCHECK(!memory_pressure_listener_);
   memory_pressure_listener_.reset(
       new MemoryPressureListener(
-          base::Bind(&DiscardableMemoryProvider::OnMemoryPressure,
+          base::Bind(&DiscardableMemoryManager::OnMemoryPressure,
                      Unretained(this))));
 }
 
-void DiscardableMemoryProvider::UnregisterMemoryPressureListener() {
+void DiscardableMemoryManager::UnregisterMemoryPressureListener() {
   AutoLock lock(lock_);
   DCHECK(memory_pressure_listener_);
   memory_pressure_listener_.reset();
 }
 
-void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
+void DiscardableMemoryManager::SetDiscardableMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   discardable_memory_limit_ = bytes;
   EnforcePolicyWithLockAcquired();
 }
 
-void DiscardableMemoryProvider::SetBytesToKeepUnderModeratePressure(
+void DiscardableMemoryManager::SetBytesToKeepUnderModeratePressure(
     size_t bytes) {
   AutoLock lock(lock_);
   bytes_to_keep_under_moderate_pressure_ = bytes;
 }
 
-void DiscardableMemoryProvider::Register(
+void DiscardableMemoryManager::Register(
     const DiscardableMemory* discardable, size_t bytes) {
   AutoLock lock(lock_);
   // A registered memory listener is currently required. This DCHECK can be
@@ -77,7 +77,7 @@ void DiscardableMemoryProvider::Register(
   allocations_.Put(discardable, Allocation(bytes));
 }
 
-void DiscardableMemoryProvider::Unregister(
+void DiscardableMemoryManager::Unregister(
     const DiscardableMemory* discardable) {
   AutoLock lock(lock_);
   AllocationMap::iterator it = allocations_.Peek(discardable);
@@ -93,7 +93,7 @@ void DiscardableMemoryProvider::Unregister(
   allocations_.Erase(it);
 }
 
-scoped_ptr<uint8, FreeDeleter> DiscardableMemoryProvider::Acquire(
+scoped_ptr<uint8, FreeDeleter> DiscardableMemoryManager::Acquire(
     const DiscardableMemory* discardable,
     bool* purged) {
   AutoLock lock(lock_);
@@ -134,7 +134,7 @@ scoped_ptr<uint8, FreeDeleter> DiscardableMemoryProvider::Acquire(
   return memory.Pass();
 }
 
-void DiscardableMemoryProvider::Release(
+void DiscardableMemoryManager::Release(
     const DiscardableMemory* discardable,
     scoped_ptr<uint8, FreeDeleter> memory) {
   AutoLock lock(lock_);
@@ -149,31 +149,31 @@ void DiscardableMemoryProvider::Release(
   EnforcePolicyWithLockAcquired();
 }
 
-void DiscardableMemoryProvider::PurgeAll() {
+void DiscardableMemoryManager::PurgeAll() {
   AutoLock lock(lock_);
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(0);
 }
 
-bool DiscardableMemoryProvider::IsRegisteredForTest(
+bool DiscardableMemoryManager::IsRegisteredForTest(
     const DiscardableMemory* discardable) const {
   AutoLock lock(lock_);
   AllocationMap::const_iterator it = allocations_.Peek(discardable);
   return it != allocations_.end();
 }
 
-bool DiscardableMemoryProvider::CanBePurgedForTest(
+bool DiscardableMemoryManager::CanBePurgedForTest(
     const DiscardableMemory* discardable) const {
   AutoLock lock(lock_);
   AllocationMap::const_iterator it = allocations_.Peek(discardable);
   return it != allocations_.end() && it->second.memory;
 }
 
-size_t DiscardableMemoryProvider::GetBytesAllocatedForTest() const {
+size_t DiscardableMemoryManager::GetBytesAllocatedForTest() const {
   AutoLock lock(lock_);
   return bytes_allocated_;
 }
 
-void DiscardableMemoryProvider::OnMemoryPressure(
+void DiscardableMemoryManager::OnMemoryPressure(
     MemoryPressureListener::MemoryPressureLevel pressure_level) {
   switch (pressure_level) {
     case MemoryPressureListener::MEMORY_PRESSURE_MODERATE:
@@ -187,18 +187,18 @@ void DiscardableMemoryProvider::OnMemoryPressure(
   NOTREACHED();
 }
 
-void DiscardableMemoryProvider::Purge() {
+void DiscardableMemoryManager::Purge() {
   AutoLock lock(lock_);
 
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(
       bytes_to_keep_under_moderate_pressure_);
 }
 
-void DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
+void DiscardableMemoryManager::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
     size_t limit) {
   TRACE_EVENT1(
       "base",
-      "DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin",
+      "DiscardableMemoryManager::PurgeLRUWithLockAcquiredUntilUsageIsWithin",
       "limit", limit);
 
   lock_.AssertAcquired();
@@ -219,7 +219,7 @@ void DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
   }
 }
 
-void DiscardableMemoryProvider::EnforcePolicyWithLockAcquired() {
+void DiscardableMemoryManager::EnforcePolicyWithLockAcquired() {
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(discardable_memory_limit_);
 }
 
diff --git a/base/memory/discardable_memory_provider.h b/base/memory/discardable_memory_manager.h
index 8ecc971..2b72c51 100644
--- a/base/memory/discardable_memory_provider.h
+++ b/base/memory/discardable_memory_manager.h
@@ -1,9 +1,9 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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.
 
-#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_
-#define BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_
+#ifndef BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_
+#define BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_
 
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
@@ -29,22 +29,22 @@ struct hash<const base::DiscardableMemory*> {
 namespace base {
 namespace internal {
 
-// The DiscardableMemoryProvider manages a collection of emulated
+// The DiscardableMemoryManager manages a collection of emulated
 // DiscardableMemory instances. It is used on platforms that do not support
 // discardable memory natively. It keeps track of all DiscardableMemory
 // instances (in case they need to be purged), and the total amount of
 // allocated memory (in case this forces a purge).
 //
-// When notified of memory pressure, the provider either purges the LRU
+// When notified of memory pressure, the manager either purges the LRU
 // memory -- if the pressure is moderate -- or all discardable memory
 // if the pressure is critical.
 //
 // NB - this class is an implementation detail. It has been exposed for testing
 // purposes. You should not need to use this class directly.
-class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
+class BASE_EXPORT_PRIVATE DiscardableMemoryManager {
  public:
-  DiscardableMemoryProvider();
-  ~DiscardableMemoryProvider();
+  DiscardableMemoryManager();
+  ~DiscardableMemoryManager();
 
   // Call this to register memory pressure listener. Must be called on a
   // thread with a MessageLoop current.
@@ -61,10 +61,10 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   // Sets the amount of memory to keep when we're under moderate pressure.
   void SetBytesToKeepUnderModeratePressure(size_t bytes);
 
-  // Adds the given discardable memory to the provider's collection.
+  // Adds the given discardable memory to the manager's collection.
   void Register(const DiscardableMemory* discardable, size_t bytes);
 
-  // Removes the given discardable memory from the provider's collection.
+  // Removes the given discardable memory from the manager's collection.
   void Unregister(const DiscardableMemory* discardable);
 
   // Returns NULL if an error occurred. Otherwise, returns the backing buffer
@@ -74,14 +74,14 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
       const DiscardableMemory* discardable, bool* purged);
 
   // Release a previously acquired backing buffer. This gives the buffer back
-  // to the provider where it can be purged if necessary.
+  // to the manager where it can be purged if necessary.
   void Release(const DiscardableMemory* discardable,
                scoped_ptr<uint8, FreeDeleter> memory);
 
   // Purges all discardable memory.
   void PurgeAll();
 
-  // Returns true if discardable memory has been added to the provider's
+  // Returns true if discardable memory has been added to the manager's
   // collection. This should only be used by tests.
   bool IsRegisteredForTest(const DiscardableMemory* discardable) const;
 
@@ -141,10 +141,10 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   // pressure.
   scoped_ptr<MemoryPressureListener> memory_pressure_listener_;
 
-  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryProvider);
+  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryManager);
 };
 
 }  // namespace internal
 }  // namespace base
 
-#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_PROVIDER_H_
+#endif  // BASE_MEMORY_DISCARDABLE_MEMORY_MANAGER_H_
diff --git a/base/memory/discardable_memory_provider_unittest.cc b/base/memory/discardable_memory_manager_unittest.cc
index 352f524..95e7c13 100644
--- a/base/memory/discardable_memory_provider_unittest.cc
+++ b/base/memory/discardable_memory_manager_unittest.cc
@@ -1,8 +1,8 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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/memory/discardable_memory_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/discardable_memory.h"
@@ -13,21 +13,21 @@
 
 namespace base {
 
-class DiscardableMemoryProviderTestBase {
+class DiscardableMemoryManagerTestBase {
  public:
   class TestDiscardableMemory : public DiscardableMemory {
    public:
     TestDiscardableMemory(
-        internal::DiscardableMemoryProvider* provider, size_t size)
-        : provider_(provider),
+        internal::DiscardableMemoryManager* manager, size_t size)
+        : manager_(manager),
           is_locked_(false) {
-      provider_->Register(this, size);
+      manager_->Register(this, size);
     }
 
     virtual ~TestDiscardableMemory() {
       if (is_locked_)
         Unlock();
-      provider_->Unregister(this);
+      manager_->Unregister(this);
     }
 
     // Overridden from DiscardableMemory:
@@ -35,7 +35,7 @@ class DiscardableMemoryProviderTestBase {
       DCHECK(!is_locked_);
 
       bool purged = false;
-      memory_ = provider_->Acquire(this, &purged);
+      memory_ = manager_->Acquire(this, &purged);
       if (!memory_)
         return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
@@ -45,7 +45,7 @@ class DiscardableMemoryProviderTestBase {
     }
     virtual void Unlock() OVERRIDE {
       DCHECK(is_locked_);
-      provider_->Release(this, memory_.Pass());
+      manager_->Release(this, memory_.Pass());
       is_locked_ = false;
     }
     virtual void* Memory() const OVERRIDE {
@@ -54,29 +54,29 @@ class DiscardableMemoryProviderTestBase {
     }
 
    private:
-    internal::DiscardableMemoryProvider* provider_;
+    internal::DiscardableMemoryManager* manager_;
     scoped_ptr<uint8, FreeDeleter> memory_;
     bool is_locked_;
 
     DISALLOW_COPY_AND_ASSIGN(TestDiscardableMemory);
   };
 
-  DiscardableMemoryProviderTestBase()
-      : provider_(new internal::DiscardableMemoryProvider) {
-    provider_->RegisterMemoryPressureListener();
+  DiscardableMemoryManagerTestBase()
+      : manager_(new internal::DiscardableMemoryManager) {
+    manager_->RegisterMemoryPressureListener();
   }
 
  protected:
   bool IsRegistered(const DiscardableMemory* discardable) {
-    return provider_->IsRegisteredForTest(discardable);
+    return manager_->IsRegisteredForTest(discardable);
   }
 
   bool CanBePurged(const DiscardableMemory* discardable) {
-    return provider_->CanBePurgedForTest(discardable);
+    return manager_->CanBePurgedForTest(discardable);
   }
 
   size_t BytesAllocated() const {
-    return provider_->GetBytesAllocatedForTest();
+    return manager_->GetBytesAllocatedForTest();
   }
 
   void* Memory(const DiscardableMemory* discardable) const {
@@ -84,16 +84,16 @@ class DiscardableMemoryProviderTestBase {
   }
 
   void SetDiscardableMemoryLimit(size_t bytes) {
-    provider_->SetDiscardableMemoryLimit(bytes);
+    manager_->SetDiscardableMemoryLimit(bytes);
   }
 
   void SetBytesToKeepUnderModeratePressure(size_t bytes) {
-    provider_->SetBytesToKeepUnderModeratePressure(bytes);
+    manager_->SetBytesToKeepUnderModeratePressure(bytes);
   }
 
   scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size) {
     scoped_ptr<TestDiscardableMemory> memory(
-        new TestDiscardableMemory(provider_.get(), size));
+        new TestDiscardableMemory(manager_.get(), size));
     if (memory->Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_PURGED)
       return scoped_ptr<DiscardableMemory>();
     return memory.PassAs<DiscardableMemory>();
@@ -101,17 +101,17 @@ class DiscardableMemoryProviderTestBase {
 
  private:
   MessageLoopForIO message_loop_;
-  scoped_ptr<internal::DiscardableMemoryProvider> provider_;
+  scoped_ptr<internal::DiscardableMemoryManager> manager_;
 };
 
-class DiscardableMemoryProviderTest
-    : public DiscardableMemoryProviderTestBase,
+class DiscardableMemoryManagerTest
+    : public DiscardableMemoryManagerTestBase,
       public testing::Test {
  public:
-  DiscardableMemoryProviderTest() {}
+  DiscardableMemoryManagerTest() {}
 };
 
-TEST_F(DiscardableMemoryProviderTest, CreateLockedMemory) {
+TEST_F(DiscardableMemoryManagerTest, CreateLockedMemory) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
@@ -120,7 +120,7 @@ TEST_F(DiscardableMemoryProviderTest, CreateLockedMemory) {
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
-TEST_F(DiscardableMemoryProviderTest, CreateLockedMemoryZeroSize) {
+TEST_F(DiscardableMemoryManagerTest, CreateLockedMemoryZeroSize) {
   size_t size = 0;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_FALSE(discardable);
@@ -128,7 +128,7 @@ TEST_F(DiscardableMemoryProviderTest, CreateLockedMemoryZeroSize) {
   EXPECT_EQ(0u, BytesAllocated());
 }
 
-TEST_F(DiscardableMemoryProviderTest, LockAfterUnlock) {
+TEST_F(DiscardableMemoryManagerTest, LockAfterUnlock) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
@@ -144,7 +144,7 @@ TEST_F(DiscardableMemoryProviderTest, LockAfterUnlock) {
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
-TEST_F(DiscardableMemoryProviderTest, LockAfterPurge) {
+TEST_F(DiscardableMemoryManagerTest, LockAfterPurge) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
@@ -167,7 +167,7 @@ TEST_F(DiscardableMemoryProviderTest, LockAfterPurge) {
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
-TEST_F(DiscardableMemoryProviderTest, LockAfterPurgeAndCannotReallocate) {
+TEST_F(DiscardableMemoryManagerTest, LockAfterPurgeAndCannotReallocate) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
@@ -187,7 +187,7 @@ TEST_F(DiscardableMemoryProviderTest, LockAfterPurgeAndCannotReallocate) {
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
-TEST_F(DiscardableMemoryProviderTest, Overflow) {
+TEST_F(DiscardableMemoryManagerTest, Overflow) {
   {
     size_t size = 1024;
     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
@@ -218,11 +218,11 @@ class PermutationTestData {
   unsigned ordering_[3];
 };
 
-class DiscardableMemoryProviderPermutationTest
-    : public DiscardableMemoryProviderTestBase,
+class DiscardableMemoryManagerPermutationTest
+    : public DiscardableMemoryManagerTestBase,
       public testing::TestWithParam<PermutationTestData> {
  public:
-  DiscardableMemoryProviderPermutationTest() {}
+  DiscardableMemoryManagerPermutationTest() {}
 
  protected:
   // Use discardable memory in order specified by ordering parameter.
@@ -253,7 +253,7 @@ class DiscardableMemoryProviderPermutationTest
 
 // Verify that memory was discarded in the correct order after applying
 // memory pressure.
-TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
+TEST_P(DiscardableMemoryManagerPermutationTest, LRUDiscardedModeratePressure) {
   CreateAndUseDiscardableMemory();
 
   SetBytesToKeepUnderModeratePressure(1024);
@@ -271,7 +271,7 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
 
 // Verify that memory was discarded in the correct order after changing
 // memory limit.
-TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
+TEST_P(DiscardableMemoryManagerPermutationTest, LRUDiscardedExceedLimit) {
   CreateAndUseDiscardableMemory();
 
   SetBytesToKeepUnderModeratePressure(1024);
@@ -285,7 +285,7 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
 
 // Verify that no more memory than necessary was discarded after changing
 // memory limit.
-TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedAmount) {
+TEST_P(DiscardableMemoryManagerPermutationTest, LRUDiscardedAmount) {
   SetBytesToKeepUnderModeratePressure(2048);
   SetDiscardableMemoryLimit(4096);
 
@@ -299,7 +299,7 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedAmount) {
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 }
 
-TEST_P(DiscardableMemoryProviderPermutationTest,
+TEST_P(DiscardableMemoryManagerPermutationTest,
        CriticalPressureFreesAllUnlocked) {
   CreateAndUseDiscardableMemory();
 
@@ -315,8 +315,8 @@ TEST_P(DiscardableMemoryProviderPermutationTest,
   }
 }
 
-INSTANTIATE_TEST_CASE_P(DiscardableMemoryProviderPermutationTests,
-                        DiscardableMemoryProviderPermutationTest,
+INSTANTIATE_TEST_CASE_P(DiscardableMemoryManagerPermutationTests,
+                        DiscardableMemoryManagerPermutationTest,
                         ::testing::Values(PermutationTestData(0, 1, 2),
                                           PermutationTestData(0, 2, 1),
                                           PermutationTestData(1, 0, 2),
@@ -324,7 +324,7 @@ INSTANTIATE_TEST_CASE_P(DiscardableMemoryProviderPermutationTests,
                                           PermutationTestData(2, 0, 1),
                                           PermutationTestData(2, 1, 0)));
 
-TEST_F(DiscardableMemoryProviderTest, NormalDestruction) {
+TEST_F(DiscardableMemoryManagerTest, NormalDestruction) {
   {
     size_t size = 1024;
     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
@@ -334,7 +334,7 @@ TEST_F(DiscardableMemoryProviderTest, NormalDestruction) {
   EXPECT_EQ(0u, BytesAllocated());
 }
 
-TEST_F(DiscardableMemoryProviderTest, DestructionWhileLocked) {
+TEST_F(DiscardableMemoryManagerTest, DestructionWhileLocked) {
   {
     size_t size = 1024;
     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
@@ -349,7 +349,7 @@ TEST_F(DiscardableMemoryProviderTest, DestructionWhileLocked) {
 
 #if !defined(NDEBUG) && !defined(OS_ANDROID) && !defined(OS_IOS)
 // Death tests are not supported with Android APKs.
-TEST_F(DiscardableMemoryProviderTest, UnlockedMemoryAccessCrashesInDebugMode) {
+TEST_F(DiscardableMemoryManagerTest, UnlockedMemoryAccessCrashesInDebugMode) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
@@ -363,10 +363,10 @@ TEST_F(DiscardableMemoryProviderTest, UnlockedMemoryAccessCrashesInDebugMode) {
 }
 #endif
 
-class ThreadedDiscardableMemoryProviderTest
-    : public DiscardableMemoryProviderTest {
+class ThreadedDiscardableMemoryManagerTest
+    : public DiscardableMemoryManagerTest {
  public:
-  ThreadedDiscardableMemoryProviderTest()
+  ThreadedDiscardableMemoryManagerTest()
       : memory_usage_thread_("memory_usage_thread"),
         thread_sync_(true, false) {
   }
@@ -395,14 +395,14 @@ class ThreadedDiscardableMemoryProviderTest
   WaitableEvent thread_sync_;
 };
 
-TEST_F(ThreadedDiscardableMemoryProviderTest, UseMemoryOnThread) {
+TEST_F(ThreadedDiscardableMemoryManagerTest, UseMemoryOnThread) {
   memory_usage_thread_.message_loop()->PostTask(
       FROM_HERE,
-      Bind(&ThreadedDiscardableMemoryProviderTest::UseMemoryHelper,
+      Bind(&ThreadedDiscardableMemoryManagerTest::UseMemoryHelper,
            Unretained(this)));
   memory_usage_thread_.message_loop()->PostTask(
       FROM_HERE,
-      Bind(&ThreadedDiscardableMemoryProviderTest::SignalHelper,
+      Bind(&ThreadedDiscardableMemoryManagerTest::SignalHelper,
            Unretained(this)));
   thread_sync_.Wait();
 }