[tracing] Add a dump provider to dump process memory totals.

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/compiler_specific.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
+#include "base/trace_event/trace_event_argument.h"
 
 // TODO(primiano): in a separate CL rename DeleteTraceLogForTesting into
 // something like base::internal::TeardownSingletonForTesting so we don't have
 // to add a new friend to singleton each time.
 class DeleteTraceLogForTesting {
  public:
   static void Delete() {
     Singleton<
         base::trace_event::MemoryDumpManager,
         LeakySingletonTraits<base::trace_event::MemoryDumpManager>>::OnExit(0);
@@ skipping 70 matching lines @@
 void MemoryDumpManager::BroadcastDumpRequest() {
   NOTREACHED();  // TODO(primiano): implement IPC synchronization.
 }
 
 // Creates a dump point for the current process and appends it to the trace.
 void MemoryDumpManager::CreateLocalDumpPoint() {
   AutoLock lock(lock_);
   // TRACE_EVENT_* macros don't induce scoped_refptr type inference, hence we
   // need the base ConvertableToTraceFormat and the upcast below. The
   // alternative would be unnecessarily expensive (double Acquire/Release).
-  scoped_refptr<ConvertableToTraceFormat> pmd(new ProcessMemoryDump());
+  scoped_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump());

[Sami, 2015/02/19 12:07:05]

Is this cast trickery now obsolete?

[Primiano Tucci (use gerrit), 2015/02/19 12:18:12]

Oh right (FTR: skyostil@ was referring to line 106 below)

[Sami, 2015/02/19 16:16:36]

Right, and also to the comment above this line :) I guess you can update it
while adding the code to actually save the dump into the trace.

 
   for (MemoryDumpProvider* dump_provider : dump_providers_enabled_) {
     dump_provider->DumpInto(static_cast<ProcessMemoryDump*>(pmd.get()));
   }
 
+  scoped_refptr<TracedValue> value(new TracedValue());
+  pmd->AsValueInto(value.get());
   // TODO(primiano): add the dump point to the trace at this point.
 }
 
 void MemoryDumpManager::OnTraceLogEnabled() {
   // TODO(primiano): at this point we query  TraceLog::GetCurrentCategoryFilter
   // to figure out (and cache) which dumpers should be enabled or not.
   // For the moment piggy back everything on the generic "memory" category.
   bool enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(kTraceCategory, &enabled);
 
   AutoLock lock(lock_);
   if (enabled) {
     dump_providers_enabled_.assign(dump_providers_registered_.begin(),
                                    dump_providers_registered_.end());
   } else {
     dump_providers_enabled_.clear();
   }
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   AutoLock lock(lock_);
   dump_providers_enabled_.clear();
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
 }
 
 }  // namespace trace_event
 }  // namespace base