Revert of base: Replace PurgeAndTruncate with Shrink function.

content/common/host_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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 341 matching lines @@
       break;
 
     // Stop eviction attempts when the LRU segment is currently in use.
     if (segments_.front()->memory()->last_known_usage() >= current_time)
       break;
 
     std::pop_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
     scoped_refptr<MemorySegment> segment = segments_.back();
     segments_.pop_back();
 
-    // Attempt to purge LRU segment. When successful, released the memory.
-    if (segment->memory()->Purge(current_time)) {
+    // Attempt to purge and truncate LRU segment. When successful, as much
+    // memory as possible will be released to the OS. How much memory is
+    // released depends on the platform. The child process should perform
+    // periodic cleanup to ensure that all memory is release within a
+    // reasonable amount of time.
+    if (segment->memory()->PurgeAndTruncate(current_time)) {
       ReleaseMemory(segment->memory());
       continue;
     }
 
     // Add memory segment (with updated usage timestamp) back on heap after
     // failed attempt to purge it.
     segments_.push_back(segment.get());
     std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
   }
 
   if (bytes_allocated_ != bytes_allocated_before_purging)
     BytesAllocatedChanged(bytes_allocated_);
 }
 
 void HostDiscardableSharedMemoryManager::ReleaseMemory(
     base::DiscardableSharedMemory* memory) {
   lock_.AssertAcquired();
 
   size_t size = memory->mapped_size();
   DCHECK_GE(bytes_allocated_, size);
   bytes_allocated_ -= size;
 
-#if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
-  // Shrink memory segment. This will immediately release the memory to the OS.
-  memory->Shrink();
-#endif
-
   // This will unmap the memory segment and drop our reference. The result
   // is that the memory will be released to the OS if the child process is
   // no longer referencing it.
   // Note: We intentionally leave the segment in the |segments| vector to
   // avoid reconstructing the heap. The element will be removed from the heap
   // when its last usage time is older than all other segments.
   memory->Close();
 }
 
 void HostDiscardableSharedMemoryManager::BytesAllocatedChanged(
@@ skipping 19 matching lines @@
 
   enforce_memory_policy_pending_ = true;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content