base: Avoid purging more discardable memory than necessary.

base/memory/discardable_memory_provider.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/containers/hash_tables.h"
 #include "base/containers/mru_cache.h"
 #include "base/debug/trace_event.h"
@@ skipping 68 matching lines @@
 void DiscardableMemoryProvider::SetDiscardableMemoryLimit(size_t bytes) {
   AutoLock lock(lock_);
   discardable_memory_limit_ = bytes;
   EnforcePolicyWithLockAcquired();
 }
 
 void DiscardableMemoryProvider::SetBytesToReclaimUnderModeratePressure(
     size_t bytes) {
   AutoLock lock(lock_);
   bytes_to_reclaim_under_moderate_pressure_ = bytes;
-  EnforcePolicyWithLockAcquired();
 }
 
 void DiscardableMemoryProvider::Register(
     const DiscardableMemory* discardable, size_t bytes) {
   AutoLock lock(lock_);
   DCHECK(allocations_.Peek(discardable) == allocations_.end());
   allocations_.Put(discardable, Allocation(bytes));
 }
 
 void DiscardableMemoryProvider::Unregister(
@@ skipping 84 matching lines @@
   return bytes_allocated_;
 }
 
 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_ < discardable_memory_limit_)
+  if (bytes_to_reclaim_under_moderate_pressure_ < bytes_allocated_)
     limit = bytes_allocated_ - bytes_to_reclaim_under_moderate_pressure_;
 
   PurgeLRUWithLockAcquiredUntilUsageIsWithin(limit);
 }
 
 void DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin(
     size_t limit) {
   TRACE_EVENT1(
       "base",
       "DiscardableMemoryProvider::PurgeLRUWithLockAcquiredUntilUsageIsWithin",
@@ skipping 11 matching lines @@
 
     size_t bytes = it->second.bytes;
     DCHECK_LE(bytes, bytes_allocated_);
     bytes_allocated_ -= bytes;
     free(it->second.memory);
     it->second.memory = NULL;
   }
 }
 
 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
 }  // namespace base