Re-land: 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 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)) {
+    // Attempt to purge LRU segment. When successful, released the memory.
+    if (segment->memory()->Purge(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(OS_POSIX) && !defined(OS_ANDROID)

[danakj, 2015/03/19 16:41:56]

Hmm.. the only thing I like a bit less is these guards in content/ it would be
easy to let them get out of sync with the ones in base/. I would slightly prefer
that only the test can get out of sync and that it would fail when doing so.

[reveman, 2015/03/19 19:23:05]

Added DISCARDABLE_SHARED_MEMORY_SHRINKING define to prevent this from getting
out of sync. I could hide the ifdef inside the Shrink function and have Shrink
be a noop when not supported but I think I prefer to keep this explicit. This
code should be aware of the fact that shrinking is not always supported and we
might handle the case when it's not a bit differently in the future.

+  // 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 18 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