content: Add DeletedDiscardableSharedMemory IPC.

content/child/child_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/child/child_discardable_shared_memory_manager.h"
 
+#include "base/atomic_sequence_num.h"
+#include "base/bind.h"
 #include "base/debug/crash_logging.h"
 #include "base/memory/discardable_shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/child_process_messages.h"
 
 namespace content {
 namespace {
 
 // Default allocation size.
 #if defined(OS_ANDROID)
 // Larger allocation size on Android to avoid reaching the FD-limit.
 const size_t kAllocationSize = 32 * 1024 * 1024;
 #else
 const size_t kAllocationSize = 4 * 1024 * 1024;
 #endif
 
+// Global atomic to generate unique discardable shared memory IDs.
+base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
+
 class DiscardableMemoryShmemChunkImpl
     : public base::DiscardableMemoryShmemChunk {
  public:
   DiscardableMemoryShmemChunkImpl(
       ChildDiscardableSharedMemoryManager* manager,
       scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
       : manager_(manager), span_(span.Pass()) {}
   ~DiscardableMemoryShmemChunkImpl() override {
     manager_->ReleaseSpan(span_.Pass());
   }
 
   // Overridden from DiscardableMemoryShmemChunk:
   bool Lock() override { return manager_->LockSpan(span_.get()); }
   void Unlock() override { manager_->UnlockSpan(span_.get()); }
   void* Memory() const override {
     return reinterpret_cast<void*>(span_->start() * base::GetPageSize());
   }
 
  private:
   ChildDiscardableSharedMemoryManager* manager_;
   scoped_ptr<DiscardableSharedMemoryHeap::Span> span_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryShmemChunkImpl);
 };
 
+void DeletedDiscardableSharedMemory(scoped_refptr<ThreadSafeSender> sender,
+                                    DiscardableSharedMemoryId id) {
+  sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
+}
+
 }  // namespace
 
 ChildDiscardableSharedMemoryManager::ChildDiscardableSharedMemoryManager(
     ThreadSafeSender* sender)
     : heap_(base::GetPageSize()), sender_(sender) {
 }
 
 ChildDiscardableSharedMemoryManager::~ChildDiscardableSharedMemoryManager() {
   // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
   // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
@@ skipping 64 matching lines @@
   heap_.ReleasePurgedMemory();
 
   // Make sure crash keys are up to date in case allocation fails.
   if (heap_.GetSize() != heap_size_prior_to_releasing_purged_memory)
     MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
   size_t pages_to_allocate =
       std::max(kAllocationSize / base::GetPageSize(), pages);
   size_t allocation_size_in_bytes = pages_to_allocate * base::GetPageSize();
 
+  DiscardableSharedMemoryId new_id =
+      g_next_discardable_shared_memory_id.GetNext();
+
   // Ask parent process to allocate a new discardable shared memory segment.
   scoped_ptr<base::DiscardableSharedMemory> shared_memory(
-      AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes));
+      AllocateLockedDiscardableSharedMemory(allocation_size_in_bytes, new_id));
 
   // Create span for allocated memory.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(
-      heap_.Grow(shared_memory.Pass(), allocation_size_in_bytes));
+      heap_.Grow(shared_memory.Pass(), allocation_size_in_bytes,
+                 base::Bind(&DeletedDiscardableSharedMemory, sender_, new_id)));
 
   // Unlock and insert any left over memory into free lists.
   if (pages < pages_to_allocate) {
     scoped_ptr<DiscardableSharedMemoryHeap::Span> leftover =
         heap_.Split(new_span.get(), pages);
     leftover->shared_memory()->Unlock(
         leftover->start() * base::GetPageSize() -
             reinterpret_cast<size_t>(leftover->shared_memory()->memory()),
         leftover->length() * base::GetPageSize());
     heap_.MergeIntoFreeLists(leftover.Pass());
@@ skipping 64 matching lines @@
     return;
 
   heap_.MergeIntoFreeLists(span.Pass());
 
   // Bytes of free memory changed.
   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 }
 
 scoped_ptr<base::DiscardableSharedMemory>
 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
-    size_t size) {
-  TRACE_EVENT1("renderer",
+    size_t size,
+    DiscardableSharedMemoryId id) {
+  TRACE_EVENT2("renderer",
                "ChildDiscardableSharedMemoryManager::"
                "AllocateLockedDiscardableSharedMemory",
-               "size",
-               size);
+               "size", size, "id", id);
 
   base::SharedMemoryHandle handle = base::SharedMemory::NULLHandle();
   sender_->Send(
       new ChildProcessHostMsg_SyncAllocateLockedDiscardableSharedMemory(
-          size, &handle));
+          size, id, &handle));
   CHECK(base::SharedMemory::IsHandleValid(handle));
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   CHECK(memory->Map(size));
   return memory.Pass();
 }
 
 void ChildDiscardableSharedMemoryManager::MemoryUsageChanged(
     size_t new_bytes_total,
     size_t new_bytes_free) const {
   TRACE_COUNTER2("renderer", "DiscardableMemoryUsage", "allocated",
                  new_bytes_total - new_bytes_free, "free", new_bytes_free);
 
   static const char kDiscardableMemoryUsageKey[] = "dm-usage";
   base::debug::SetCrashKeyValue(kDiscardableMemoryUsageKey,
                                 base::Uint64ToString(new_bytes_total));
 
   static const char kDiscardableMemoryUsageFreeKey[] = "dm-usage-free";
   base::debug::SetCrashKeyValue(kDiscardableMemoryUsageFreeKey,
                                 base::Uint64ToString(new_bytes_free));
 }
 
 }  // namespace content