Re-land: base: Use MADV_REMOVE instead of ftruncate to purge 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 307 matching lines @@
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
   if (!memory->ShareToProcess(process_handle, shared_memory_handle)) {
     LOG(ERROR) << "Cannot share discardable memory segment";
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
+  // Close file descriptor to avoid running out.
+  memory->Close();
+
   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 69 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();
 
+    // Simply drop the reference and continue if memory has already been
+    // unmapped. This happens when a memory segment has been deleted by
+    // the client.
+    if (!segment->memory()->mapped_size())
+      continue;
+
     // Attempt to purge LRU segment. When successful, released the memory.
     if (segment->memory()->Purge(current_time)) {
-#if defined(DISCARDABLE_SHARED_MEMORY_SHRINKING)
-      size_t size = segment->memory()->mapped_size();
-      DCHECK_GE(bytes_allocated_, size);
-      bytes_allocated_ -= size;
-      // Shrink memory segment. This will immediately release the memory to
-      // the OS.
-      segment->memory()->Shrink();
-      DCHECK_EQ(segment->memory()->mapped_size(), 0u);
-#endif
       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);
   }
 
@@ skipping 39 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