Re-land: base: Replace PurgeAndTruncate with Shrink function.

base/memory/discardable_shared_memory.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 "base/memory/discardable_shared_memory.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
@@ skipping 98 matching lines @@
 DiscardableSharedMemory::DiscardableSharedMemory(
     SharedMemoryHandle shared_memory_handle)
     : shared_memory_(shared_memory_handle, false),
       mapped_size_(0),
       locked_page_count_(0) {
 }
 
 DiscardableSharedMemory::~DiscardableSharedMemory() {
 }
 
+// static
+bool DiscardableSharedMemory::IsShrinkingSupported() {
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
+  // ftruncate() can be used on to shrink memory segments.
+  return true;
+#else
+  return false;
+#endif
+}
+
 bool DiscardableSharedMemory::CreateAndMap(size_t size) {
   CheckedNumeric<size_t> checked_size = size;
   checked_size += AlignToPageSize(sizeof(SharedState));
   if (!checked_size.IsValid())
     return false;
 
   if (!shared_memory_.CreateAndMapAnonymous(checked_size.ValueOrDie()))
     return false;
 
   mapped_size_ =
@@ skipping 189 matching lines @@
     last_known_usage_ = result.GetLockState() == SharedState::LOCKED
                             ? current_time
                             : result.GetTimestamp();
     return false;
   }
 
   last_known_usage_ = Time();
   return true;
 }
 
-bool DiscardableSharedMemory::PurgeAndTruncate(Time current_time) {
-  if (!Purge(current_time))
-    return false;
-
-#if defined(OS_POSIX)
-  // Truncate shared memory to size of SharedState.
+void DiscardableSharedMemory::Shrink() {
+  DCHECK(IsShrinkingSupported());
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (SharedMemory::IsHandleValid(handle)) {
-    if (HANDLE_EINTR(ftruncate(handle.fd, sizeof(SharedState))) != 0)
+    // Truncate shared memory to size of SharedState.
+    if (HANDLE_EINTR(
+            ftruncate(handle.fd, AlignToPageSize(sizeof(SharedState)))) != 0) {
       DPLOG(ERROR) << "ftruncate() failed";
+      return;
+    }
+
+    mapped_size_ = 0;
   }
 #endif
-
-  return true;
 }
 
 bool DiscardableSharedMemory::IsMemoryResident() const {
   DCHECK(shared_memory_.memory());
 
   SharedState result(subtle::NoBarrier_Load(
       &SharedStateFromSharedMemory(shared_memory_)->value.i));
 
   return result.GetLockState() == SharedState::LOCKED ||
          !result.GetTimestamp().is_null();
 }
 
 void DiscardableSharedMemory::Close() {
   shared_memory_.Unmap();
   shared_memory_.Close();
   mapped_size_ = 0;
 }
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base