Move purging memory from OnMemoryStateChange() to OnPurgeMemory() in discardable_memory

components/discardable_memory/service/discardable_shared_memory_manager.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 "components/discardable_memory/service/discardable_shared_memory_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 387 matching lines @@
 }
 
 size_t DiscardableSharedMemoryManager::GetBytesAllocated() {
   base::AutoLock lock(lock_);
 
   return bytes_allocated_;
 }
 
 void DiscardableSharedMemoryManager::OnMemoryStateChange(
     base::MemoryState state) {
+  // Don't use SetMemoryLimit() as it free up existing allocations.

[bashi, 2017/02/07 02:42:22]

As noted in
https://cs.chromium.org/chromium/src/base/memory/memory_coordinator_client.h?...,
we don't have to free up existing allocation on state change. OnPurgeMemory() is
called as needed.

[reveman, 2017/02/07 03:34:07]

nit: s/free/frees/

maybe also mention here that OnPurgeMemory() is called to actually free up
memory.

[bashi, 2017/02/07 04:31:35]

Done.

+  base::AutoLock lock(lock_);
   switch (state) {
     case base::MemoryState::NORMAL:
-      SetMemoryLimit(default_memory_limit_);
+      memory_limit_ = default_memory_limit_;
       break;
     case base::MemoryState::THROTTLED:
-      SetMemoryLimit(0);
+      memory_limit_ = 0;
       break;
     case base::MemoryState::SUSPENDED:
     // Note that SUSPENDED never occurs in the main browser process so far.
     // Fall through.
     case base::MemoryState::UNKNOWN:
       NOTREACHED();
       break;
   }
 }
 
+void DiscardableSharedMemoryManager::OnPurgeMemory() {
+  base::AutoLock lock(lock_);
+  ReduceMemoryUsageUntilWithinLimit(0);
+}
+
 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
     int client_id,
     size_t size,
     int32_t id,
     base::SharedMemoryHandle* shared_memory_handle) {
   base::AutoLock lock(lock_);
 
   // Make sure |id| is not already in use.
   MemorySegmentMap& client_segments = clients_[client_id];
   if (client_segments.find(id) != client_segments.end()) {
@@ skipping 183 matching lines @@
     return;
 
   enforce_memory_policy_pending_ = true;
   DCHECK(enforce_memory_policy_task_runner_);
   enforce_memory_policy_task_runner_->PostDelayedTask(
       FROM_HERE, enforce_memory_policy_callback_,
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace discardable_memory