content: Close in-process discardable memory segments.

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 139 matching lines @@
 
   locked_page_count_ = AlignToPageSize(mapped_size_) / base::GetPageSize();
 #if DCHECK_IS_ON()
   for (size_t page = 0; page < locked_page_count_; ++page)
     locked_pages_.insert(page);
 #endif
 
   return true;
 }
 
+bool DiscardableSharedMemory::Unmap() {
+  if (!shared_memory_.Unmap())
+    return false;
+
+  mapped_size_ = 0;
+  return true;
+}
+
 DiscardableSharedMemory::LockResult DiscardableSharedMemory::Lock(
     size_t offset, size_t length) {
   DCHECK_EQ(AlignToPageSize(offset), offset);
   DCHECK_EQ(AlignToPageSize(length), length);
 
   // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
   DCHECK(shared_memory_.memory());
 
@@ skipping 35 matching lines @@
   // Detect incorrect usage by keeping track of exactly what pages are locked.
   for (auto page = start; page < end; ++page) {
     auto result = locked_pages_.insert(page);
     DCHECK(result.second);
   }
   DCHECK_EQ(locked_pages_.size(), locked_page_count_);
 #endif
 
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
-  DCHECK(SharedMemory::IsHandleValid(handle));
-  if (ashmem_pin_region(
-          handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
-    return PURGED;
+  if (SharedMemory::IsHandleValid(handle)) {
+    if (ashmem_pin_region(
+            handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
+      return PURGED;
+    }
   }
 #endif
 
   return SUCCESS;
 }
 
 void DiscardableSharedMemory::Unlock(size_t offset, size_t length) {
   DCHECK_EQ(AlignToPageSize(offset), offset);
   DCHECK_EQ(AlignToPageSize(length), length);
 
   // Calls to this function must be synchronized properly.
   DFAKE_SCOPED_LOCK(thread_collision_warner_);
 
   // Zero for length means "everything onward".
   if (!length)
     length = AlignToPageSize(mapped_size_) - offset;
 
   DCHECK(shared_memory_.memory());
 
 #if defined(OS_ANDROID)
   SharedMemoryHandle handle = shared_memory_.handle();
-  DCHECK(SharedMemory::IsHandleValid(handle));
-  if (ashmem_unpin_region(
-          handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
-    DPLOG(ERROR) << "ashmem_unpin_region() failed";
+  if (SharedMemory::IsHandleValid(handle)) {
+    if (ashmem_unpin_region(
+            handle.fd, AlignToPageSize(sizeof(SharedState)) + offset, length)) {
+      DPLOG(ERROR) << "ashmem_unpin_region() failed";
+    }
   }
 #endif
 
   size_t start = offset / base::GetPageSize();
   size_t end = start + length / base::GetPageSize();
   DCHECK_LT(start, end);
   DCHECK_LE(end, AlignToPageSize(mapped_size_) / base::GetPageSize());
 
   // Remove pages from |locked_page_count_|.
   // Note: Unlocking a page that is not locked is an error.
@@ skipping 75 matching lines @@
   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;
 }
 
 #if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
 void DiscardableSharedMemory::Shrink() {
 #if defined(OS_POSIX)
   SharedMemoryHandle handle = shared_memory_.handle();
   if (!SharedMemory::IsHandleValid(handle))
     return;
 
   // 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;
 #else
   NOTIMPLEMENTED();
 #endif
 }
 #endif
 
 Time DiscardableSharedMemory::Now() const {
   return Time::Now();
 }
 
 }  // namespace base