[tracing] Dump child processes' memory metrics in browser

base/trace_event/memory_dump_manager.cc

 // Copyright 2015 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/trace_event/memory_dump_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/memory_dump_session_state.h"
 #include "base/trace_event/memory_profiler_allocation_context.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
-#if !defined(OS_NACL)
-#include "base/trace_event/process_memory_totals_dump_provider.h"
-#endif
-
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 #include "base/trace_event/malloc_dump_provider.h"
-#include "base/trace_event/process_memory_maps_dump_provider.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "base/trace_event/java_heap_dump_provider_android.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/trace_event/winheap_dump_provider_win.h"
 #endif
 
@@ skipping 104 matching lines @@
                                    bool is_coordinator) {
   {
     AutoLock lock(lock_);
     DCHECK(delegate);
     DCHECK(!delegate_);
     delegate_ = delegate;
     is_coordinator_ = is_coordinator;
   }
 
 // Enable the core dump providers.
-#if !defined(OS_NACL)
-  RegisterDumpProvider(ProcessMemoryTotalsDumpProvider::GetInstance(),
-                       "ProcessMemoryTotals", nullptr);
-#endif
+#if defined(OS_ANDROID)
+  const ProcessHandle current_process = GetCurrentProcessHandle();
+  scoped_ptr<ProcessMemoryTotalsDumpProvider> totals_provider(
+      ProcessMemoryTotalsDumpProvider::CreateForProcess(current_process));
+  RegisterDumpProvider(totals_provider.get(), "ProcessMemoryTotals", nullptr);
+  process_totals_providers_map_.insert(current_process, totals_provider.Pass());
+
+  scoped_ptr<ProcessMemoryMapsDumpProvider> mmaps_provider(
+      ProcessMemoryMapsDumpProvider::CreateForProcess(current_process));
+  RegisterDumpProvider(mmaps_provider.get(), "ProcessMemoryMaps", nullptr);
+  process_mmaps_providers_map_.insert(current_process, mmaps_provider.Pass());
+
+  RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
+                       nullptr);
+#endif  // defined(OS_ANDROID)
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
-  RegisterDumpProvider(ProcessMemoryMapsDumpProvider::GetInstance(),
-                       "ProcessMemoryMaps", nullptr);
   RegisterDumpProvider(MallocDumpProvider::GetInstance(), "Malloc", nullptr);
-#endif
-
-#if defined(OS_ANDROID)
-  RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
-                       nullptr);
-#endif
-
-#if defined(OS_WIN)
+#elif defined(OS_WIN)
   RegisterDumpProvider(WinHeapDumpProvider::GetInstance(), "WinHeap", nullptr);
 #endif
 
   // If tracing was enabled before initializing MemoryDumpManager, we missed the
   // OnTraceLogEnabled() event. Synthetize it so we can late-join the party.
   bool is_tracing_already_enabled = TraceLog::GetInstance()->IsEnabled();
   TRACE_EVENT0(kTraceCategory, "init");  // Add to trace-viewer category list.
   TraceLog::GetInstance()->AddEnabledStateObserver(this);
   if (is_tracing_already_enabled)
     OnTraceLogEnabled();
@@ skipping 415 matching lines @@
   // or will deadlock (e.g., if ContinueAsyncProcessDump() tries to acquire it).
   periodic_dump_timer_.Stop();
   if (dump_thread)
     dump_thread->Stop();
 }
 
 uint64_t MemoryDumpManager::GetTracingProcessId() const {
   return delegate_->GetTracingProcessId();
 }
 
+void MemoryDumpManager::RegisterProcessMetricsProvidersFor(
+    ProcessHandle process) {
+#if defined(OS_LINUX)
+  scoped_ptr<ProcessMemoryTotalsDumpProvider> totals_provider(
+      ProcessMemoryTotalsDumpProvider::CreateForProcess(process));
+  MemoryDumpProvider::Options totals_options = {process};
+  RegisterDumpProvider(totals_provider.get(), "ProcessMemoryTotals", nullptr,
+                       totals_options);
+  process_totals_providers_map_.insert(process, totals_provider.Pass());
+
+  scoped_ptr<ProcessMemoryMapsDumpProvider> mmaps_provider(
+      ProcessMemoryMapsDumpProvider::CreateForProcess(process));
+  MemoryDumpProvider::Options mmaps_options = {process};
+  RegisterDumpProvider(mmaps_provider.get(), "ProcessMemoryMaps", nullptr,
+                       mmaps_options);
+  process_mmaps_providers_map_.insert(process, mmaps_provider.Pass());
+#endif  // defined(OS_LINUX)
+}
+
+void MemoryDumpManager::UnregisterProcessMetricsProvidersFor(
+    ProcessHandle process) {
+#if defined(OS_LINUX)
+  ProcessTotalsDumpProvidersMap::const_iterator totals_it =
+      process_totals_providers_map_.find(process);
+  DCHECK(totals_it != process_totals_providers_map_.end());
+  UnregisterDumpProvider(totals_it->second);
+  process_totals_providers_map_.erase(totals_it);
+
+  ProcessMapsDumpProvidersMap::const_iterator mmaps_it =
+      process_mmaps_providers_map_.find(process);
+  DCHECK(mmaps_it != process_mmaps_providers_map_.begin());
+  UnregisterDumpProvider(mmaps_it->second);
+  process_mmaps_providers_map_.erase(mmaps_it);
+#endif  // defined(OS_LINUX)
+}
+
 MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo(
     MemoryDumpProvider* dump_provider,
     const char* name,
     const scoped_refptr<SingleThreadTaskRunner>& task_runner,
     const MemoryDumpProvider::Options& options)
     : dump_provider(dump_provider),
       name(name),
       task_runner(task_runner),
       options(options),
       consecutive_failures(0),
@@ skipping 21 matching lines @@
       session_state(session_state),
       callback(callback),
       callback_task_runner(MessageLoop::current()->task_runner()),
       dump_thread_task_runner(dump_thread_task_runner) {}
 
 MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() {
 }
 
 }  // namespace trace_event
 }  // namespace base