[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_serialization_state.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 214 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 std::unordered_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 (allocation_register.begin() != allocation_register.end()) {
     // We shouldn't end up here unless we're doing a detailed dump with
     // heap profiling enabled and if that is the case tracing should be
     // enabled which sets up the heap profiler serialization state.
     if (!heap_profiler_serialization_state()) {
       NOTREACHED();
       return;
     }
     DCHECK_EQ(0ul, heap_dumps_.count(allocator_name));
-    std::unique_ptr<TracedValue> heap_dump = ExportHeapDump(
-        metrics_by_context, *heap_profiler_serialization_state());
+    std::unique_ptr<TracedValue> heap_dump = SerializeHeapDump(
+        allocation_register, *heap_profiler_serialization_state());
     heap_dumps_[allocator_name] = std::move(heap_dump);
   }
 
+  TraceEventMemoryOverhead overhead;
+  allocation_register.EstimateTraceMemoryOverhead(&overhead);
   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 44 matching lines @@
   }
 
   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"
+    auto profile_data = SerializeHeapProfileEventData(
+        heap_dumps_, *heap_profiler_serialization_state_);
+    value->SetValue("heaps_v2", *profile_data);
   }
 
   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();
@@ skipping 27 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