base: Discardable memory types.

base/memory/discardable_memory_provider_unittest.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/memory/discardable_memory.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 13 matching lines @@
       provider_->Register(this, size);
     }
 
     virtual ~TestDiscardableMemory() {
       if (is_locked_)
         Unlock();
       provider_->Unregister(this);
     }
 
     // Overridden from DiscardableMemory:
-    virtual LockDiscardableMemoryStatus Lock() OVERRIDE {
+    virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
       DCHECK(!is_locked_);
 
       bool purged = false;
       memory_ = provider_->Acquire(this, &purged);
       if (!memory_)
-        return DISCARDABLE_MEMORY_FAILED;
+        return DISCARDABLE_MEMORY_LOCK_STATUS_FAILED;
 
       is_locked_ = true;
-      return purged ? DISCARDABLE_MEMORY_PURGED : DISCARDABLE_MEMORY_SUCCESS;
+      return purged ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
+                    : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
     }
     virtual void Unlock() OVERRIDE {
       DCHECK(is_locked_);
       provider_->Release(this, memory_.Pass());
       is_locked_ = false;
     }
     virtual void* Memory() const OVERRIDE {
       DCHECK(memory_);
       return memory_.get();
     }
@@ skipping 32 matching lines @@
     provider_->SetDiscardableMemoryLimit(bytes);
   }
 
   void SetBytesToReclaimUnderModeratePressure(size_t bytes) {
     provider_->SetBytesToReclaimUnderModeratePressure(bytes);
   }
 
   scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size) {
     scoped_ptr<TestDiscardableMemory> memory(
         new TestDiscardableMemory(provider_.get(), size));
-    if (memory->Lock() != DISCARDABLE_MEMORY_PURGED)
+    if (memory->Lock() != DISCARDABLE_MEMORY_LOCK_STATUS_PURGED)
       return scoped_ptr<DiscardableMemory>();
     return memory.PassAs<DiscardableMemory>();
   }
 
  private:
   MessageLoop message_loop_;
   scoped_ptr<internal::DiscardableMemoryProvider> provider_;
 };
 
 class DiscardableMemoryProviderTest
@@ skipping 25 matching lines @@
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
   EXPECT_EQ(1024u, BytesAllocated());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 
   // Now unlock so we can lock later.
   discardable->Unlock();
   EXPECT_TRUE(CanBePurged(discardable.get()));
 
-  EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, discardable->Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable->Lock());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
 TEST_F(DiscardableMemoryProviderTest, LockAfterPurge) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
   EXPECT_EQ(1024u, BytesAllocated());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 
   // Now unlock so we can lock later.
   discardable->Unlock();
   EXPECT_TRUE(CanBePurged(discardable.get()));
 
   // Force the system to purge.
   MemoryPressureListener::NotifyMemoryPressure(
       MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
 
   // Required because ObserverListThreadSafe notifies via PostTask.
   RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable->Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable->Lock());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
 TEST_F(DiscardableMemoryProviderTest, LockAfterPurgeAndCannotReallocate) {
   size_t size = 1024;
   const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
   EXPECT_TRUE(IsRegistered(discardable.get()));
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
   EXPECT_EQ(1024u, BytesAllocated());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 
   // Now unlock so we can lock later.
   discardable->Unlock();
   EXPECT_TRUE(CanBePurged(discardable.get()));
 
   // Set max allowed allocation to 1 byte. This will make cause the memory
   // to be purged.
   SetDiscardableMemoryLimit(1);
 
-  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable->Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable->Lock());
   EXPECT_FALSE(CanBePurged(discardable.get()));
 }
 
 TEST_F(DiscardableMemoryProviderTest, Overflow) {
   {
     size_t size = 1024;
     const scoped_ptr<DiscardableMemory> discardable(CreateLockedMemory(size));
     EXPECT_TRUE(IsRegistered(discardable.get()));
     EXPECT_NE(static_cast<void*>(NULL), Memory(discardable.get()));
     EXPECT_EQ(1024u, BytesAllocated());
@@ skipping 31 matching lines @@
   // Use discardable memory in order specified by ordering parameter.
   void CreateAndUseDiscardableMemory() {
     for (int i = 0; i < 3; ++i) {
       discardables_[i] = CreateLockedMemory(1024);
       EXPECT_TRUE(discardables_[i]);
       EXPECT_NE(static_cast<void*>(NULL), Memory(discardables_[i].get()));
       discardables_[i]->Unlock();
     }
     for (int i = 0; i < 3; ++i) {
       int index = GetParam().ordering()[i];
-      EXPECT_NE(DISCARDABLE_MEMORY_FAILED, discardables_[index]->Lock());
+      EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED,
+                discardables_[index]->Lock());
       // Leave i == 0 locked.
       if (i > 0)
         discardables_[index]->Unlock();
     }
   }
 
   DiscardableMemory* discardable(unsigned position) {
     return discardables_[GetParam().ordering()[position]].get();
   }
 
  private:
   scoped_ptr<DiscardableMemory> discardables_[3];
 };
 
 // Verify that memory was discarded in the correct order after applying
 // memory pressure.
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
   CreateAndUseDiscardableMemory();
 
   SetBytesToReclaimUnderModeratePressure(1024);
   MemoryPressureListener::NotifyMemoryPressure(
       MemoryPressureListener::MEMORY_PRESSURE_MODERATE);
   RunLoop().RunUntilIdle();
 
-  EXPECT_NE(DISCARDABLE_MEMORY_FAILED, discardable(2)->Lock());
-  EXPECT_NE(DISCARDABLE_MEMORY_SUCCESS, discardable(1)->Lock());
+  EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, discardable(2)->Lock());
+  EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(1)->Lock());
   // 0 should still be locked.
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 }
 
 // Verify that memory was discarded in the correct order after changing
 // memory limit.
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
   CreateAndUseDiscardableMemory();
 
   SetBytesToReclaimUnderModeratePressure(1024);
   SetDiscardableMemoryLimit(2048);
 
-  EXPECT_NE(DISCARDABLE_MEMORY_FAILED, discardable(2)->Lock());
-  EXPECT_NE(DISCARDABLE_MEMORY_SUCCESS, discardable(1)->Lock());
+  EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, discardable(2)->Lock());
+  EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(1)->Lock());
   // 0 should still be locked.
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 }
 
 // Verify that no more memory than necessary was discarded after changing
 // memory limit.
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedAmount) {
   SetBytesToReclaimUnderModeratePressure(2048);
   SetDiscardableMemoryLimit(4096);
 
   CreateAndUseDiscardableMemory();
 
   SetDiscardableMemoryLimit(2048);
 
-  EXPECT_EQ(DISCARDABLE_MEMORY_SUCCESS, discardable(2)->Lock());
-  EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable(1)->Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS, discardable(2)->Lock());
+  EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable(1)->Lock());
   // 0 should still be locked.
   EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
 }
 
 TEST_P(DiscardableMemoryProviderPermutationTest,
        CriticalPressureFreesAllUnlocked) {
   CreateAndUseDiscardableMemory();
 
   MemoryPressureListener::NotifyMemoryPressure(
       MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
   RunLoop().RunUntilIdle();
 
   for (int i = 0; i < 3; ++i) {
     if (i == 0)
       EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(i)));
     else
-      EXPECT_EQ(DISCARDABLE_MEMORY_PURGED, discardable(i)->Lock());
+      EXPECT_EQ(DISCARDABLE_MEMORY_LOCK_STATUS_PURGED, discardable(i)->Lock());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(DiscardableMemoryProviderPermutationTests,
                         DiscardableMemoryProviderPermutationTest,
                         ::testing::Values(PermutationTestData(0, 1, 2),
                                           PermutationTestData(0, 2, 1),
                                           PermutationTestData(1, 0, 2),
                                           PermutationTestData(1, 2, 0),
                                           PermutationTestData(2, 0, 1),
@@ skipping 76 matching lines @@
       Bind(&ThreadedDiscardableMemoryProviderTest::UseMemoryHelper,
            Unretained(this)));
   memory_usage_thread_.message_loop()->PostTask(
       FROM_HERE,
       Bind(&ThreadedDiscardableMemoryProviderTest::SignalHelper,
            Unretained(this)));
   thread_sync_.Wait();
 }
 
 }  // namespace base