content: Close in-process discardable memory segments.

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 105 matching lines @@
 
   // Note: Use DiscardableSharedMemoryHeap for in-process allocation
   // of discardable memory if the cost of each allocation is too high.
   base::SharedMemoryHandle handle;
   AllocateLockedDiscardableSharedMemory(current_process_handle, size, new_id,
                                         &handle);
   CHECK(base::SharedMemory::IsHandleValid(handle));
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   CHECK(memory->Map(size));
+  // Close file descriptor to avoid running out.
+  memory->Close();
   return make_scoped_ptr(new DiscardableMemoryImpl(
       memory.Pass(),
       base::Bind(
           &HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory,
           base::Unretained(this), new_id, current_process_handle)));
 }
 
 void HostDiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForChild(
         base::ProcessHandle process_handle,
@@ skipping 94 matching lines @@
   base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_;
   checked_bytes_allocated += memory->mapped_size();
   if (!checked_bytes_allocated.IsValid()) {
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
   bytes_allocated_ = checked_bytes_allocated.ValueOrDie();
   BytesAllocatedChanged(bytes_allocated_);
 
+#if !defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
+  // Close file descriptor to avoid running out.
+  memory->Close();
+#endif
+
   scoped_refptr<MemorySegment> segment(new MemorySegment(memory.Pass()));
   process_segments[id] = segment.get();
   segments_.push_back(segment.get());
   std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
 
   if (bytes_allocated_ > memory_limit_)
     ScheduleEnforceMemoryPolicy();
 }
 
 void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
@@ skipping 108 matching lines @@
   size_t size = memory->mapped_size();
   DCHECK_GE(bytes_allocated_, size);
   bytes_allocated_ -= size;
 
   // 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->Unmap();
   memory->Close();
 }
 
 void HostDiscardableSharedMemoryManager::BytesAllocatedChanged(
     size_t new_bytes_allocated) const {
   TRACE_COUNTER1("renderer_host", "TotalDiscardableMemoryUsage",
                  new_bytes_allocated);
 
   static const char kTotalDiscardableMemoryAllocatedKey[] =
       "total-discardable-memory-allocated";
@@ skipping 13 matching lines @@
 
   enforce_memory_policy_pending_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content