[tracing] Switch to new heap dump format.

base/trace_event/malloc_dump_provider.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/malloc_dump_provider.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/allocator/allocator_shim.h"
 #include "base/allocator/features.h"
+#include "base/bind.h"
 #include "base/debug/profiler.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.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/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <malloc/malloc.h>
 #else
 #include <malloc.h>
 #endif
 #if defined(OS_WIN)
@@ skipping 263 matching lines @@
   // The dumps of the heap profiler should be created only when heap profiling
   // was enabled (--enable-heap-profiling) AND a DETAILED dump is requested.
   // However, when enabled, the overhead of the heap profiler should be always
   // reported to avoid oscillations of the malloc total in LIGHT dumps.
 
   tid_dumping_heap_ = PlatformThread::CurrentId();
   // At this point the Insert/RemoveAllocation hooks will ignore this thread.
   // Enclosing all the temporary data structures in a scope, so that the heap
   // profiler does not see unbalanced malloc/free calls from these containers.
   {
-    TraceEventMemoryOverhead overhead;
-    std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
     if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
-      ShardedAllocationRegister::OutputMetrics shim_metrics =
-          allocation_register_.UpdateAndReturnsMetrics(metrics_by_context);
+      struct ShimMetrics {
+        size_t size;
+        size_t count;
+      };
+      ShimMetrics shim_metrics = {0};
+      auto visit_allocation = [](ShimMetrics* metrics,
+                                 const AllocationRegister::Allocation& alloc) {
+        metrics->size += alloc.size;
+        metrics->count += 1;
+      };
+      allocation_register_.VisitAllocations(base::BindRepeating(
+          visit_allocation, base::Unretained(&shim_metrics)));
 
       // Aggregate data for objects allocated through the shim.
       inner_dump->AddScalar("shim_allocated_objects_size",
                             MemoryAllocatorDump::kUnitsBytes,
                             shim_metrics.size);
       inner_dump->AddScalar("shim_allocator_object_count",
                             MemoryAllocatorDump::kUnitsObjects,
                             shim_metrics.count);
     }
-    allocation_register_.EstimateTraceMemoryOverhead(&overhead);
 
-    pmd->DumpHeapUsage(metrics_by_context, overhead, "malloc");
+    pmd->DumpHeapUsage(allocation_register_, "malloc");
   }
   tid_dumping_heap_ = kInvalidThreadId;
 
   return true;
 }
 
 void MallocDumpProvider::OnHeapProfilingEnabled(bool enabled) {
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   if (enabled) {
     allocation_register_.SetEnabled();
@@ skipping 35 matching lines @@
   if (tid_dumping_heap_ != kInvalidThreadId &&
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   if (!allocation_register_.is_enabled())
     return;
   allocation_register_.Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base