[tracing] Dump child processes' memory metrics in browser

base/trace_event/memory_dump_manager.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 
 #include <set>
 
 #include "base/atomicops.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/process_memory_dump.h"
+#include "base/trace_event/process_memory_maps_dump_provider.h"
+#include "base/trace_event/process_memory_totals_dump_provider.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 
 class SingleThreadTaskRunner;
 class Thread;
 
 namespace trace_event {
 
 class MemoryDumpManagerDelegate;
@@ skipping 61 matching lines @@
                          const MemoryDumpCallback& callback);
 
   // Same as above (still asynchronous), but without callback.
   void RequestGlobalDump(MemoryDumpType dump_type,
                          MemoryDumpLevelOfDetail level_of_detail);
 
   // TraceLog::EnabledStateObserver implementation.
   void OnTraceLogEnabled() override;
   void OnTraceLogDisabled() override;
 
+  // Registers and unregisters the process metrics dump providers for the
+  // |process|. Some processes cannot access metrics due to sandbox. To
+  // workaround the issue the coordinator process dumps statistics about the

[Primiano Tucci (use gerrit), 2015/11/03 15:14:08]

the manager should not need to know about all this.
Why do you want to keep track of them here?

+  // associated processes.
+  void RegisterProcessMetricsProvidersFor(ProcessHandle process);
+  void UnregisterProcessMetricsProvidersFor(ProcessHandle process);
+
   // Returns the MemoryDumpSessionState object, which is shared by all the
   // ProcessMemoryDump and MemoryAllocatorDump instances through all the tracing
   // session lifetime.
   const scoped_refptr<MemoryDumpSessionState>& session_state() const {
     return session_state_;
   }
 
   // Returns a unique id for identifying the processes. The id can be
   // retrieved by child processes only when tracing is enabled. This is
   // intended to express cross-process sharing of memory dumps on the
@@ skipping 12 matching lines @@
   void set_dumper_registrations_ignored_for_testing(bool ignored) {
     dumper_registrations_ignored_for_testing_ = ignored;
   }
 
  private:
   friend struct DefaultDeleter<MemoryDumpManager>;  // For the testing instance.
   friend struct DefaultSingletonTraits<MemoryDumpManager>;
   friend class MemoryDumpManagerDelegate;
   friend class MemoryDumpManagerTest;
 
+  using ProcessTotalsDumpProvidersMap =
+      ScopedPtrMap<ProcessHandle, scoped_ptr<ProcessMemoryTotalsDumpProvider>>;
+  using ProcessMapsDumpProvidersMap =
+      ScopedPtrMap<ProcessHandle, scoped_ptr<ProcessMemoryMapsDumpProvider>>;
+
   // Descriptor struct used to hold information about registered MDPs. It is
   // deliberately copyable, in order to allow it to be used as std::set value.
   struct MemoryDumpProviderInfo {
     MemoryDumpProviderInfo(
         MemoryDumpProvider* dump_provider,
         const char* name,
         const scoped_refptr<SingleThreadTaskRunner>& task_runner,
         const MemoryDumpProvider::Options& options);
     ~MemoryDumpProviderInfo();
 
@@ skipping 91 matching lines @@
 
   // Continues the ProcessMemoryDump started by CreateProcessDump(), hopping
   // across threads as needed as specified by MDPs in RegisterDumpProvider().
   void ContinueAsyncProcessDump(
       scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state);
 
   // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by thread
   // affinity (MDPs belonging to the same thread are adjacent).
   MemoryDumpProviderInfoSet dump_providers_;
 
+  // MemoryDumpManager owns the memory maps and totals providers for all the
+  // associated processes.
+  ProcessTotalsDumpProvidersMap process_totals_providers_map_;
+  ProcessMapsDumpProvidersMap process_mmaps_providers_map_;
+
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
 
   MemoryDumpManagerDelegate* delegate_;  // Not owned.
 
   // When true, this instance is in charge of coordinating periodic dumps.
   bool is_coordinator_;
 
   // Protects from concurrent accesses to the |dump_providers_*| and |delegate_|
   // to guard against disabling logging while dumping on another thread.
@@ skipping 43 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_