[tracing] Switch to new heap dump format.

base/trace_event/process_memory_dump.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/process_memory_dump.h"
 
 #include <errno.h>
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/stringprintf.h"
-#include "base/trace_event/heap_profiler_heap_dump_writer.h"
+#include "base/trace_event/heap_profiler_allocation_register.h"
+#include "base/trace_event/heap_profiler_event_writer.h"
 #include "base/trace_event/memory_infra_background_whitelist.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
 #if defined(OS_IOS)
 #include <mach/vm_page_size.h>
 #endif
 
 #if defined(OS_POSIX)
@@ skipping 207 matching lines @@
   mad->set_flags(MemoryAllocatorDump::Flags::WEAK);
   return mad;
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::GetSharedGlobalAllocatorDump(
     const MemoryAllocatorDumpGuid& guid) const {
   return GetAllocatorDump(GetSharedGlobalAllocatorDumpName(guid));
 }
 
 void ProcessMemoryDump::DumpHeapUsage(
-    const base::hash_map<base::trace_event::AllocationContext,
-        base::trace_event::AllocationMetrics>& metrics_by_context,
-    base::trace_event::TraceEventMemoryOverhead& overhead,
+    const AllocationRegister& allocation_register,
     const char* allocator_name) {
-  if (!metrics_by_context.empty()) {
+  if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::DETAILED &&
+      allocation_register.begin() != allocation_register.end()) {
     DCHECK_EQ(0ul, heap_dumps_.count(allocator_name));
-    std::unique_ptr<TracedValue> heap_dump = ExportHeapDump(
-        metrics_by_context, *session_state());
+    std::unique_ptr<TracedValue> heap_dump =
+        SerializeHeapDump(allocation_register, *session_state());
     heap_dumps_[allocator_name] = std::move(heap_dump);
   }
 
+  TraceEventMemoryOverhead overhead;
+  allocation_register.EstimateTraceMemoryOverhead(&overhead);

[ssid, 2017/03/16 02:09:20]

This part should be outside the if condition which states DETAILED dump.
For all kinds of dump we want to estimate memory overehad and dump it under
malloc. See the my previous comment.

[DmitrySkiba, 2017/03/17 04:01:38]

This is exactly how it's working now.

   std::string base_name = base::StringPrintf("tracing/heap_profiler_%s",
                                              allocator_name);
   overhead.DumpInto(base_name.c_str(), this);
 }
 
 void ProcessMemoryDump::Clear() {
   if (has_process_totals_) {
     process_totals_.Clear();
     has_process_totals_ = false;
   }
@@ skipping 43 matching lines @@
     value->EndDictionary();
   }
 
   if (allocator_dumps_.size() > 0) {
     value->BeginDictionary("allocators");
     for (const auto& allocator_dump_it : allocator_dumps_)
       allocator_dump_it.second->AsValueInto(value);
     value->EndDictionary();
   }
 
-  if (heap_dumps_.size() > 0) {
-    value->BeginDictionary("heaps");
-    for (const auto& name_and_dump : heap_dumps_)
-      value->SetValueWithCopiedName(name_and_dump.first, *name_and_dump.second);
-    value->EndDictionary();  // "heaps"
-  }
-
   value->BeginArray("allocators_graph");
   for (const MemoryAllocatorDumpEdge& edge : allocator_dumps_edges_) {
     value->BeginDictionary();
     value->SetString("source", edge.source.ToString());
     value->SetString("target", edge.target.ToString());
     value->SetInteger("importance", edge.importance);
     value->SetString("type", edge.type);
     value->EndDictionary();
   }
   value->EndArray();
@@ skipping 25 matching lines @@
 
 MemoryAllocatorDump* ProcessMemoryDump::GetBlackHoleMad() {
   DCHECK(is_black_hole_non_fatal_for_testing_);
   if (!black_hole_mad_)
     black_hole_mad_.reset(new MemoryAllocatorDump("discarded", this));
   return black_hole_mad_.get();
 }
 
 }  // namespace trace_event
 }  // namespace base