base: Replace BytesToReclaimUnderModeratePressure with BytesToKeepUnderModeratePressure.

Instead of purging a fixed amount of discardable memory
under moderate pressure, purge until within some specific
usage. This is a better behavior and less complicated to
implement.

BUG=
TEST=base_unittests --gtest_filter=DiscardableMemoryProvider*

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

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

3 files changed, 23 insertions, 27 deletions

diff --git a/base/memory/discardable_memory_provider.cc b/base/memory/discardable_memory_provider.cc
index 3df7e686..5d43b448 100644
--- a/base/memory/discardable_memory_provider.cc
+++ b/base/memory/discardable_memory_provider.cc
@@ -19,8 +19,8 @@ namespace {
 // This is admittedly pretty magical. It's approximately enough memory for four
 // 2560x1600 images.
 static const size_t kDefaultDiscardableMemoryLimit = 64 * 1024 * 1024;
-static const size_t kDefaultBytesToReclaimUnderModeratePressure =
-    (3 * kDefaultDiscardableMemoryLimit) / 4;
+static const size_t kDefaultBytesToKeepUnderModeratePressure =
+    kDefaultDiscardableMemoryLimit / 4;
 
 }  // namespace
 
@@ -28,8 +28,8 @@ DiscardableMemoryProvider::DiscardableMemoryProvider()
     : allocations_(AllocationMap::NO_AUTO_EVICT),
       bytes_allocated_(0),
       discardable_memory_limit_(kDefaultDiscardableMemoryLimit),
-      bytes_to_reclaim_under_moderate_pressure_(
-          kDefaultBytesToReclaimUnderModeratePressure) {
+      bytes_to_keep_under_moderate_pressure_(
+          kDefaultBytesToKeepUnderModeratePressure) {
 }
 
 DiscardableMemoryProvider::~DiscardableMemoryProvider() {
@@ -59,10 +59,10 @@ void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
   EnforcePolicyWithLockAcquired();
 }
 
-void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
+void DiscardableMemoryProvider::SetBytesToKeepUnderModeratePressure(
     size_t bytes) {
   AutoLock lock(lock_);
-  bytes_to_reclaim_under_moderate_pressure_ = bytes;
+  bytes_to_keep_under_moderate_pressure_ = bytes;
 }
 
 void DiscardableMemoryProvider::Register(
@@ -190,14 +190,8 @@ void DiscardableMemoryProvider::OnMemoryPressure(
 void DiscardableMemoryProvider::Purge() {
   AutoLock lock(lock_);
 
-  if (bytes_to_reclaim_under_moderate_pressure_ == 0)
-    return;
-
-  size_t limit = 0;
-  if (bytes_to_reclaim_under_moderate_pressure_ < bytes_allocated_)
-    limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
-
-  PurgeLRUWithLockAcquiredUntilUsageIsWithin(limit);
+  PurgeLRUWithLockAcquiredUntilUsageIsWithin(
+      bytes_to_keep_under_moderate_pressure_);
 }
 
 void DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
diff --git a/base/memory/discardable_memory_provider.h b/base/memory/discardable_memory_provider.h
index 8a06353..8ecc971 100644
--- a/base/memory/discardable_memory_provider.h
+++ b/base/memory/discardable_memory_provider.h
@@ -58,8 +58,8 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   // having no limit at all.
   void SetDiscardableMemoryLimit(size_t bytes);
 
-  // Sets the amount of memory to reclaim when we're under moderate pressure.
-  void SetBytesToReclaimUnderModeratePressure(size_t bytes);
+  // 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.
   void Register(const DiscardableMemory* discardable, size_t bytes);
@@ -109,8 +109,8 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   void OnMemoryPressure(
       MemoryPressureListener::MemoryPressureLevel pressure_level);
 
-  // Purges |bytes_to_reclaim_under_moderate_pressure_| bytes of
-  // discardable memory.
+  // Purges until discardable memory usage is within
+  // |bytes_to_keep_under_moderate_pressure_|.
   void Purge();
 
   // Purges least recently used memory until usage is less or equal to |limit|.
@@ -130,12 +130,12 @@ class BASE_EXPORT_PRIVATE DiscardableMemoryProvider {
   // The total amount of allocated discardable memory.
   size_t bytes_allocated_;
 
-  // The maximum number of bytes of discardable memory that may be allocated
-  // before we assume moderate memory pressure.
+  // The maximum number of bytes of discardable memory that may be allocated.
   size_t discardable_memory_limit_;
 
-  // Under moderate memory pressure, we will purge this amount of memory.
-  size_t bytes_to_reclaim_under_moderate_pressure_;
+  // Under moderate memory pressure, we will purge until usage is within this
+  // limit.
+  size_t bytes_to_keep_under_moderate_pressure_;
 
   // Allows us to be respond when the system reports that it is under memory
   // pressure.
diff --git a/base/memory/discardable_memory_provider_unittest.cc b/base/memory/discardable_memory_provider_unittest.cc
index 2050700..352f524 100644
--- a/base/memory/discardable_memory_provider_unittest.cc
+++ b/base/memory/discardable_memory_provider_unittest.cc
@@ -87,8 +87,8 @@ class DiscardableMemoryProviderTestBase {
     provider_->SetDiscardableMemoryLimit(bytes);
   }
 
-  void SetBytesToReclaimUnderModeratePressure(size_t bytes) {
-    provider_->SetBytesToReclaimUnderModeratePressure(bytes);
+  void SetBytesToKeepUnderModeratePressure(size_t bytes) {
+    provider_->SetBytesToKeepUnderModeratePressure(bytes);
   }
 
   scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size) {
@@ -256,7 +256,9 @@ class DiscardableMemoryProviderPermutationTest
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
   CreateAndUseDiscardableMemory();
 
-  SetBytesToReclaimUnderModeratePressure(1024);
+  SetBytesToKeepUnderModeratePressure(1024);
+  SetDiscardableMemoryLimit(2048);
+
   MemoryPressureListener::NotifyMemoryPressure(
       MemoryPressureListener::MEMORY_PRESSURE_MODERATE);
   RunLoop().RunUntilIdle();
@@ -272,7 +274,7 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedModeratePressure) {
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
   CreateAndUseDiscardableMemory();
 
-  SetBytesToReclaimUnderModeratePressure(1024);
+  SetBytesToKeepUnderModeratePressure(1024);
   SetDiscardableMemoryLimit(2048);
 
   EXPECT_NE(DISCARDABLE_MEMORY_LOCK_STATUS_FAILED, discardable(2)->Lock());
@@ -284,7 +286,7 @@ TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedExceedLimit) {
 // Verify that no more memory than necessary was discarded after changing
 // memory limit.
 TEST_P(DiscardableMemoryProviderPermutationTest, LRUDiscardedAmount) {
-  SetBytesToReclaimUnderModeratePressure(2048);
+  SetBytesToKeepUnderModeratePressure(2048);
   SetDiscardableMemoryLimit(4096);
 
   CreateAndUseDiscardableMemory();