base: Avoid purging more discardable memory than necessary.

In situations when discardable memory usage is above the limit,
instead of purging the amount of memory that we would try to
reclaim under moderate memory pressure, purge only what is
necessary to stay below the limit.

This simplifies the code and makes it easier to understand how
memory is purged as a result of reaching the memory limit.

BUG=237681
TEST=base_unittests --gtest_filter=DiscardableMemoryProviderPermutationTests/DiscardableMemoryProviderPermutationTest.LRUDiscardedAmount/*

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

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

3 files changed, 22 insertions, 17 deletions

diff --git a/base/memory/discardable_memory_provider.cc b/base/memory/discardable_memory_provider.cc
index a0ba0ad..9567384 100644
--- a/base/memory/discardable_memory_provider.cc
+++ b/base/memory/discardable_memory_provider.cc
@@ -86,7 +86,6 @@ void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
     size_t bytes) {
   AutoLock lock(lock_);
   bytes_to_reclaim_under_moderate_pressure_ = bytes;
-  EnforcePolicyWithLockAcquired();
 }
 
 void DiscardableMemoryProvider::Register(
@@ -191,7 +190,7 @@ void DiscardableMemoryProvider::Purge() {
     return;
 
   size_t limit = 0;
-  if (bytes_to_reclaim_under_moderate_pressure_ < discardable_memory_limit_)
+  if (bytes_to_reclaim_under_moderate_pressure_ < bytes_allocated_)
     limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
 
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(limit);
@@ -223,17 +222,7 @@ void DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
 }
 
 void DiscardableMemoryProvider::EnforcePolicyWithLockAcquired() {
-  lock_.AssertAcquired();
-
-  bool exceeded_bound = bytes_allocated_ > discardable_memory_limit_;
-  if (!exceeded_bound || !bytes_to_reclaim_under_moderate_pressure_)
-    return;
-
-  size_t limit = 0;
-  if (bytes_to_reclaim_under_moderate_pressure_ < discardable_memory_limit_)
-    limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
-
-  PurgeLRUWithLockAcquiredUntilUsageIsWithin(limit);
+  PurgeLRUWithLockAcquiredUntilUsageIsWithin(discardable_memory_limit_);
 }
 
 }  // namespace internal
diff --git a/base/memory/discardable_memory_provider.h b/base/memory/discardable_memory_provider.h
index 005cc1d..ea887a3 100644
--- a/base/memory/discardable_memory_provider.h
+++ b/base/memory/discardable_memory_provider.h
@@ -55,8 +55,8 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   static void SetInstanceForTest(DiscardableMemoryProvider* provider);
 
   // The maximum number of bytes of discardable memory that may be allocated
-  // before we assume moderate memory pressure. If this amount is zero, it is
-  // interpreted as having no limit at all.
+  // before we force a purge. If this amount is zero, it is interpreted as
+  // having no limit at all.
   void SetDiscardableMemoryLimit(size_t bytes);
 
   // Sets the amount of memory to reclaim when we're under moderate pressure.
@@ -110,8 +110,8 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   static void NotifyMemoryPressure(
       MemoryPressureListener::MemoryPressureLevel pressure_level);
 
-  // Purges least recently used memory based on the value of
-  // |bytes_to_reclaim_under_moderate_pressure_|.
+  // Purges |bytes_to_reclaim_under_moderate_pressure_| bytes of
+  // discardable memory.
   void Purge();
 
   // Purges least recently used memory until usage is less or equal to |limit|.
diff --git a/base/memory/discardable_memory_provider_unittest.cc b/base/memory/discardable_memory_provider_unittest.cc
index f033a05..a1294fb 100644
--- a/base/memory/discardable_memory_provider_unittest.cc
+++ b/base/memory/discardable_memory_provider_unittest.cc
@@ -232,6 +232,22 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
   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());
+  // 0 should still be locked.
+  EXPECT_NE(static_cast<void*>(NULL), Memory(discardable(0)));
+}
+
 TEST_P(DiscardableMemoryProviderPermutationTest,
        CriticalPressureFreesAllUnlocked) {
   CreateAndUseDiscardableMemory();