Adding discardable memory dump provider.

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_memory.h"
 #include "base/memory/discardable_shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/process/memory.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.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
 
+const char kMemoryDumperFriendlyName[] = "Discardable";
+
 // Global atomic to generate unique discardable shared memory IDs.
 base::StaticAtomicSequenceNumber g_next_discardable_shared_memory_id;
 
 class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
   DiscardableMemoryImpl(ChildDiscardableSharedMemoryManager* manager,
                         scoped_ptr<DiscardableSharedMemoryHeap::Span> span)
       : manager_(manager), span_(span.Pass()), is_locked_(true) {}
 
   ~DiscardableMemoryImpl() override {
@@ skipping 35 matching lines @@
 void SendDeletedDiscardableSharedMemoryMessage(
     scoped_refptr<ThreadSafeSender> sender,
     DiscardableSharedMemoryId id) {
   sender->Send(new ChildProcessHostMsg_DeletedDiscardableSharedMemory(id));
 }
 
 }  // namespace
 
 ChildDiscardableSharedMemoryManager::ChildDiscardableSharedMemoryManager(
     ThreadSafeSender* sender)
-    : heap_(base::GetPageSize()), sender_(sender) {
+    : MemoryDumpProvider(base::ThreadTaskRunnerHandle::Get()),
+      heap_(base::GetPageSize()),
+      sender_(sender) {
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this);
 }
 
 ChildDiscardableSharedMemoryManager::~ChildDiscardableSharedMemoryManager() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
   // TODO(reveman): Determine if this DCHECK can be enabled. crbug.com/430533
   // DCHECK_EQ(heap_.GetSize(), heap_.GetSizeOfFreeLists());
   if (heap_.GetSize())
     MemoryUsageChanged(0, 0);
 }
 
 scoped_ptr<base::DiscardableMemory>
 ChildDiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(
     size_t size) {
   base::AutoLock lock(lock_);
@@ skipping 64 matching lines @@
 
   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, new_id));
 
   // Create span for allocated memory.
   scoped_ptr<DiscardableSharedMemoryHeap::Span> new_span(heap_.Grow(
-      shared_memory.Pass(), allocation_size_in_bytes,
+      shared_memory.Pass(), allocation_size_in_bytes, new_id,
       base::Bind(&SendDeletedDiscardableSharedMemoryMessage, 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());
   }
 
   MemoryUsageChanged(heap_.GetSize(), heap_.GetSizeOfFreeLists());
 
   return make_scoped_ptr(new DiscardableMemoryImpl(this, new_span.Pass()));
 }
 
+bool ChildDiscardableSharedMemoryManager::DumpInto(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  return heap_.DumpInto(pmd);
+}
+
+const char* ChildDiscardableSharedMemoryManager::GetFriendlyName() const {
+  return kMemoryDumperFriendlyName;
+}
+
 void ChildDiscardableSharedMemoryManager::ReleaseFreeMemory() {
   base::AutoLock lock(lock_);
 
   size_t heap_size_prior_to_releasing_memory = heap_.GetSize();
 
   // Release both purged and free memory.
   heap_.ReleasePurgedMemory();
   heap_.ReleaseFreeMemory();
 
   if (heap_.GetSize() != heap_size_prior_to_releasing_memory)
@@ skipping 81 matching lines @@
       "discardable-memory-allocated";
   base::debug::SetCrashKeyValue(kDiscardableMemoryAllocatedKey,
                                 base::Uint64ToString(new_bytes_total));
 
   static const char kDiscardableMemoryFreeKey[] = "discardable-memory-free";
   base::debug::SetCrashKeyValue(kDiscardableMemoryFreeKey,
                                 base::Uint64ToString(new_bytes_free));
 }
 
 }  // namespace content