base: Add soft memory limit to DiscardableMemoryManager.

base/memory/discardable_memory.h

 // Copyright (c) 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.
 
 #ifndef BASE_MEMORY_DISCARDABLE_MEMORY_H_
 #define BASE_MEMORY_DISCARDABLE_MEMORY_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 79 matching lines @@
   // Gets the preferred discardable memory type.
   static DiscardableMemoryType GetPreferredType();
 
   // Create a DiscardableMemory instance with specified |type| and |size|.
   static scoped_ptr<DiscardableMemory> CreateLockedMemoryWithType(
       DiscardableMemoryType type, size_t size);
 
   // Create a DiscardableMemory instance with preferred type and |size|.
   static scoped_ptr<DiscardableMemory> CreateLockedMemory(size_t size);
 
+  // Call this when idle. Discardable memory implementations might use this

[willchan no longer on Chromium, 2014/06/27 14:12:56]

I'd give more guidance on "idle". Specifically, discuss the tradeoffs. Calling
this too often will hurt performance, whereas calling it too infrequently will
bloat memory usage. At least, that's how I understand it :)

Actually, perhaps we should rename this. This function name assumes too much
about how the caller might want to use it. Yes, most likely the sane way to use
this is in an idle handler, but functionally what it does is try to discard
memory up to a threshold.

[reveman, 2014/06/27 20:38:02]

Correct. I've updated the comment.
Good idea. I changed the name to ReduceMemoryUsage and made it clear in the
comment what this function might do.

+  // to reduce memory footprint. Returns true if there's no need to call this
+  // again until memory instances have been used. This indicates that all
+  // discardable memory implementations have done as much cleanup as they
+  // will be able to do.
+  static bool IdleNotification();
+
   // Locks the memory so that it will not be purged by the system. Returns
   // DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS on success. If the return value is
   // DISCARDABLE_MEMORY_LOCK_STATUS_FAILED then this object should be
   // discarded and a new one should be created. If the return value is
   // DISCARDABLE_MEMORY_LOCK_STATUS_PURGED then the memory is present but any
   // data that was in it is gone.
   virtual DiscardableMemoryLockStatus Lock() WARN_UNUSED_RESULT = 0;
 
   // Unlocks the memory so that it can be purged by the system. Must be called
   // after every successful lock call.
   virtual void Unlock() = 0;
 
   // Returns the memory address held by this object. The object must be locked
   // before calling this. Otherwise, this will cause a DCHECK error.
   virtual void* Memory() const = 0;
 
   // Testing utility calls.
 
   // Purge all discardable memory in the system. This call has global effects
   // across all running processes, so it should only be used for testing!
   static void PurgeForTesting();
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_DISCARDABLE_MEMORY_H_