Re-land: base: Introduce an explicit call for reducing emulated discardable memory usage.

base/memory/discardable_memory_manager_unittest.cc

 // 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_manager.h"
 
 #include "base/bind.h"
-#include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 class TestAllocationImpl : public internal::DiscardableMemoryManagerAllocation {
  public:
   TestAllocationImpl() : is_allocated_(false), is_locked_(false) {}
@@ skipping 42 matching lines @@
 
  private:
   // Overriden from internal::DiscardableMemoryManager:
   virtual TimeTicks Now() const OVERRIDE { return now_; }
 
   TimeTicks now_;
 };
 
 class DiscardableMemoryManagerTestBase {
  public:
-  DiscardableMemoryManagerTestBase() {
-    manager_.RegisterMemoryPressureListener();
-  }
+  DiscardableMemoryManagerTestBase() {}
 
  protected:
   enum LockStatus {
     LOCK_STATUS_FAILED,
     LOCK_STATUS_PURGED,
     LOCK_STATUS_SUCCESS
   };
 
   size_t BytesAllocated() const { return manager_.GetBytesAllocatedForTest(); }
 
@@ skipping 36 matching lines @@
     manager_.Register(allocation, bytes);
     return Lock(allocation);
   }
 
   bool CanBePurged(TestAllocationImpl* allocation) const {
     return manager_.CanBePurgedForTest(allocation);
   }
 
   void SetNow(TimeTicks now) { manager_.SetNow(now); }
 
+  void PurgeAll() { return manager_.PurgeAll(); }
+
   bool ReduceMemoryUsage() { return manager_.ReduceMemoryUsage(); }
 
+  void ReduceMemoryUsageUntilWithinModeratePressureLimit() {
+    manager_.ReduceMemoryUsageUntilWithinModeratePressureLimit();
+  }
+
  private:
-  MessageLoopForIO message_loop_;
   TestDiscardableMemoryManagerImpl manager_;
 };
 
 class DiscardableMemoryManagerTest : public DiscardableMemoryManagerTestBase,
                                      public testing::Test {
  public:
   DiscardableMemoryManagerTest() {}
 };
 
 TEST_F(DiscardableMemoryManagerTest, CreateAndLock) {
@@ skipping 41 matching lines @@
   TestAllocationImpl allocation;
   RegisterAndLock(&allocation, size);
   EXPECT_EQ(1024u, BytesAllocated());
   EXPECT_FALSE(CanBePurged(&allocation));
 
   // Now unlock so we can lock later.
   Unlock(&allocation);
   EXPECT_TRUE(CanBePurged(&allocation));
 
   // Force the system to purge.
-  MemoryPressureListener::NotifyMemoryPressure(
-      MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
-
-  // Required because ObserverListThreadSafe notifies via PostTask.
-  RunLoop().RunUntilIdle();
+  PurgeAll();
 
   EXPECT_EQ(LOCK_STATUS_PURGED, Lock(&allocation));
   EXPECT_FALSE(CanBePurged(&allocation));
 
   Unlock(&allocation);
   Unregister(&allocation);
 }
 
 TEST_F(DiscardableMemoryManagerTest, LockAfterPurgeAndCannotReallocate) {
   size_t size = 1024;
@@ skipping 84 matching lines @@
       if (allocation_[i].is_locked())
         Unlock(&allocation_[i]);
       Unregister(&allocation_[i]);
     }
   }
 
  private:
   TestAllocationImpl allocation_[3];
 };
 
-// Verify that memory was discarded in the correct order after applying
-// memory pressure.
+// Verify that memory was discarded in the correct order after reducing usage to
+// moderate pressure limit.
 TEST_P(DiscardableMemoryManagerPermutationTest, LRUDiscardedModeratePressure) {
   RegisterAndUseAllocations();
 
   SetBytesToKeepUnderModeratePressure(1024);
   SetMemoryLimit(2048);
 
-  MemoryPressureListener::NotifyMemoryPressure(
-      MemoryPressureListener::MEMORY_PRESSURE_MODERATE);
-  RunLoop().RunUntilIdle();
+  ReduceMemoryUsageUntilWithinModeratePressureLimit();
 
   EXPECT_NE(LOCK_STATUS_FAILED, Lock(allocation(2)));
   EXPECT_EQ(LOCK_STATUS_PURGED, Lock(allocation(1)));
   // 0 should still be locked.
   EXPECT_TRUE(allocation(0)->is_locked());
 
   UnlockAndUnregisterAllocations();
 }
 
 // Verify that memory was discarded in the correct order after changing
@@ skipping 26 matching lines @@
   EXPECT_EQ(LOCK_STATUS_PURGED, Lock(allocation(1)));
   // 0 should still be locked.
   EXPECT_TRUE(allocation(0)->is_locked());
 
   UnlockAndUnregisterAllocations();
 }
 
 TEST_P(DiscardableMemoryManagerPermutationTest, PurgeFreesAllUnlocked) {
   RegisterAndUseAllocations();
 
-  MemoryPressureListener::NotifyMemoryPressure(
-      MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
-  RunLoop().RunUntilIdle();
+  PurgeAll();
 
   for (int i = 0; i < 3; ++i) {
     if (i == 0)
       EXPECT_TRUE(allocation(i)->is_locked());
     else
       EXPECT_EQ(LOCK_STATUS_PURGED, Lock(allocation(i)));
   }
 
   UnlockAndUnregisterAllocations();
 }
@@ skipping 122 matching lines @@
            Unretained(this)));
   memory_usage_thread_.message_loop()->PostTask(
       FROM_HERE,
       Bind(&ThreadedDiscardableMemoryManagerTest::SignalHelper,
            Unretained(this)));
   thread_sync_.Wait();
 }
 
 }  // namespace
 }  // namespace base