base: Add soft memory limit to DiscardableMemoryManager.

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"
@@ skipping 27 matching lines @@
   bool is_locked() const { return is_locked_; }
 
  private:
   bool is_allocated_;
   bool is_locked_;
 };
 
 // Tests can assume that the default limit is at least 1024. Tests that rely on
 // something else needs to explicit set the limit.
 const size_t kDefaultMemoryLimit = 1024;
+const size_t kDefaultSoftMemoryLimit = kDefaultMemoryLimit;
 const size_t kDefaultBytesToKeepUnderModeratePressure = kDefaultMemoryLimit;
 
+class TestDiscardableMemoryManagerImpl
+    : public internal::DiscardableMemoryManager {
+ public:
+  TestDiscardableMemoryManagerImpl()
+      : DiscardableMemoryManager(kDefaultMemoryLimit,
+                                 kDefaultSoftMemoryLimit,
+                                 kDefaultBytesToKeepUnderModeratePressure,
+                                 TimeDelta::Max()) {
+  }
+
+  void SetNow(TimeTicks now) { now_ = now; }
+
+ protected:
+  // Overriden from internal::DiscardableMemoryManager:
+  virtual TimeTicks Now() const OVERRIDE {
+    return now_;
+  }
+
+ private:
+  TimeTicks now_;
+};
+
 class DiscardableMemoryManagerTestBase {
  public:
-  DiscardableMemoryManagerTestBase()
-      : manager_(kDefaultMemoryLimit,
-                 kDefaultBytesToKeepUnderModeratePressure) {
+  DiscardableMemoryManagerTestBase() {
     manager_.RegisterMemoryPressureListener();
   }
 
  protected:
   enum LockStatus {
     LOCK_STATUS_FAILED,
     LOCK_STATUS_PURGED,
     LOCK_STATUS_SUCCESS
   };
 
   size_t BytesAllocated() const { return manager_.GetBytesAllocatedForTest(); }
 
   void SetMemoryLimit(size_t bytes) { manager_.SetMemoryLimit(bytes); }
 
+  void SetSoftMemoryLimit(size_t bytes) { manager_.SetSoftMemoryLimit(bytes); }
+
   void SetBytesToKeepUnderModeratePressure(size_t bytes) {
     manager_.SetBytesToKeepUnderModeratePressure(bytes);
   }
 
+  void SetHardMemoryLimitExpirationTime(TimeDelta time) {
+    manager_.SetHardMemoryLimitExpirationTime(time);
+  }
+
   void Register(TestAllocationImpl* allocation, size_t bytes) {
     manager_.Register(allocation, bytes);
   }
 
   void Unregister(TestAllocationImpl* allocation) {
     manager_.Unregister(allocation);
   }
 
   bool IsRegistered(TestAllocationImpl* allocation) const {
     return manager_.IsRegisteredForTest(allocation);
@@ skipping 12 matching lines @@
 
   LockStatus RegisterAndLock(TestAllocationImpl* allocation, size_t bytes) {
     manager_.Register(allocation, bytes);
     return Lock(allocation);
   }
 
   bool CanBePurged(TestAllocationImpl* allocation) const {
     return manager_.CanBePurgedForTest(allocation);
   }
 
+  void SetNow(TimeTicks now) {
+    manager_.SetNow(now);
+  }
+
+  bool IdleNotification() {
+    return manager_.IdleNotification();
+  }
+
  private:
   MessageLoopForIO message_loop_;
-  internal::DiscardableMemoryManager manager_;
+  TestDiscardableMemoryManagerImpl manager_;
 };
 
 class DiscardableMemoryManagerTest : public DiscardableMemoryManagerTestBase,
                                      public testing::Test {
  public:
   DiscardableMemoryManagerTest() {}
 };
 
 TEST_F(DiscardableMemoryManagerTest, CreateAndLock) {
   size_t size = 1024;
@@ skipping 267 matching lines @@
     EXPECT_EQ(1024u, BytesAllocated());
     Unlock(&allocation);
     EXPECT_TRUE(CanBePurged(&allocation));
     SetMemoryLimit(0);
     EXPECT_EQ(0u, BytesAllocated());
     Unregister(&allocation);
   }
   EXPECT_EQ(0u, BytesAllocated());
 }
 
+TEST_F(DiscardableMemoryManagerTest, IdleNotification) {
+  SetMemoryLimit(3072);
+  SetSoftMemoryLimit(1024);
+  SetHardMemoryLimitExpirationTime(TimeDelta::FromInternalValue(1));
+
+  size_t size = 1024;
+  TestAllocationImpl allocation[3];
+  RegisterAndLock(&allocation[0], size);
+  RegisterAndLock(&allocation[1], size);
+  RegisterAndLock(&allocation[2], size);
+  EXPECT_EQ(3072u, BytesAllocated());
+
+  // Above soft limit but nothing that can be purged.
+  EXPECT_FALSE(IdleNotification());
+
+  SetNow(TimeTicks::FromInternalValue(0));
+  Unlock(&allocation[0]);
+
+  // Above soft limit but still nothing that can be purged as all unlocked
+  // allocation is within the hard limit cutoff time.
+  EXPECT_FALSE(IdleNotification());
+
+  SetNow(TimeTicks::FromInternalValue(1));
+  Unlock(&allocation[1]);
+
+  // One unlocked allocation is no longer within the hard limit cutoff time. It
+  // should be purged. IdleNotification() should return false as we're not yet
+  // within the soft memory limit.
+  EXPECT_FALSE(IdleNotification());
+  EXPECT_EQ(2048u, BytesAllocated());
+
+  // One more unlocked allocation is no longer within the hard limit cutoff
+  // time. It should be purged. IdleNotification() should return true as we're
+  // now within the soft memory limit.
+  SetNow(TimeTicks::FromInternalValue(2));
+  EXPECT_TRUE(IdleNotification());
+  EXPECT_EQ(1024u, BytesAllocated());
+
+  Unlock(&allocation[2]);
+
+  Unregister(&allocation[0]);
+  Unregister(&allocation[1]);
+  Unregister(&allocation[2]);
+}
+
 class ThreadedDiscardableMemoryManagerTest
     : public DiscardableMemoryManagerTest {
  public:
   ThreadedDiscardableMemoryManagerTest()
       : memory_usage_thread_("memory_usage_thread"),
         thread_sync_(true, false) {}
 
   virtual void SetUp() OVERRIDE { memory_usage_thread_.Start(); }
 
   virtual void TearDown() OVERRIDE { memory_usage_thread_.Stop(); }
@@ skipping 19 matching lines @@
            Unretained(this)));
   memory_usage_thread_.message_loop()->PostTask(
       FROM_HERE,
       Bind(&ThreadedDiscardableMemoryManagerTest::SignalHelper,
            Unretained(this)));
   thread_sync_.Wait();
 }
 
 }  // namespace
 }  // namespace base