[tracing] Switch to new heap dump format.

base/trace_event/process_memory_dump_unittest.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 <stddef.h>
 
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
+#include "base/trace_event/heap_profiler_allocation_register.h"
 #include "base/trace_event/memory_allocator_dump_guid.h"
 #include "base/trace_event/memory_infra_background_whitelist.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
@@ skipping 61 matching lines @@
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad2->flags());
 
   traced_value.reset(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
 TEST(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
-  std::unordered_map<AllocationContext, AllocationMetrics> metrics_by_context;
-  metrics_by_context[AllocationContext()] = { 1, 1 };
-  TraceEventMemoryOverhead overhead;
+  AllocationRegister allocation_register(10, 10);
+  allocation_register.Insert("", 100, AllocationContext());
 
   scoped_refptr<HeapProfilerSerializationState>
       heap_profiler_serialization_state = new HeapProfilerSerializationState;
-  heap_profiler_serialization_state->SetStackFrameDeduplicator(
-      WrapUnique(new StackFrameDeduplicator));
-  heap_profiler_serialization_state->SetTypeNameDeduplicator(
-      WrapUnique(new TypeNameDeduplicator));
+  heap_profiler_serialization_state->CreateDeduplicators();
   std::unique_ptr<ProcessMemoryDump> pmd1(new ProcessMemoryDump(
       heap_profiler_serialization_state.get(), kDetailedDumpArgs));
+
   auto* mad1_1 = pmd1->CreateAllocatorDump("pmd1/mad1");
   auto* mad1_2 = pmd1->CreateAllocatorDump("pmd1/mad2");
   pmd1->AddOwnershipEdge(mad1_1->guid(), mad1_2->guid());
-  pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump1");
-  pmd1->DumpHeapUsage(metrics_by_context, overhead, "pmd1/heap_dump2");
+  pmd1->DumpHeapUsage(allocation_register, "pmd1/heap_dump1");
+  pmd1->DumpHeapUsage(allocation_register, "pmd1/heap_dump2");
 
   std::unique_ptr<ProcessMemoryDump> pmd2(new ProcessMemoryDump(
       heap_profiler_serialization_state.get(), kDetailedDumpArgs));
   auto* mad2_1 = pmd2->CreateAllocatorDump("pmd2/mad1");
   auto* mad2_2 = pmd2->CreateAllocatorDump("pmd2/mad2");
   pmd2->AddOwnershipEdge(mad2_1->guid(), mad2_2->guid());
-  pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump1");
-  pmd2->DumpHeapUsage(metrics_by_context, overhead, "pmd2/heap_dump2");
+  pmd2->DumpHeapUsage(allocation_register, "pmd2/heap_dump1");
+  pmd2->DumpHeapUsage(allocation_register, "pmd2/heap_dump2");
 
   MemoryAllocatorDumpGuid shared_mad_guid1(1);
   MemoryAllocatorDumpGuid shared_mad_guid2(2);
   auto* shared_mad1 = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
   auto* shared_mad2 =
       pmd2->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
 
   pmd1->TakeAllDumpsFrom(pmd2.get());
 
   // Make sure that pmd2 is empty but still usable after it has been emptied.
   ASSERT_TRUE(pmd2->allocator_dumps().empty());
   ASSERT_TRUE(pmd2->allocator_dumps_edges().empty());
   ASSERT_TRUE(pmd2->heap_dumps().empty());
   pmd2->CreateAllocatorDump("pmd2/this_mad_stays_with_pmd2");
   ASSERT_EQ(1u, pmd2->allocator_dumps().size());
   ASSERT_EQ(1u, pmd2->allocator_dumps().count("pmd2/this_mad_stays_with_pmd2"));
   pmd2->AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
                          MemoryAllocatorDumpGuid(4242));
 
   // Check that calling AsValueInto() doesn't cause a crash.
   pmd2->AsValueInto(traced_value.get());
 
   // Free the |pmd2| to check that the memory ownership of the two MAD(s)
   // has been transferred to |pmd1|.
   pmd2.reset();
 
   // Now check that |pmd1| has been effectively merged.
-  ASSERT_EQ(6u, pmd1->allocator_dumps().size());
+  // Note that DumpHeapUsage() adds an implicit dump for AllocationRegister's
+  // memory overhead.
+  ASSERT_EQ(10u, pmd1->allocator_dumps().size());
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad1"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd2/mad1"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
   ASSERT_EQ(2u, pmd1->allocator_dumps_edges().size());
   ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
   ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
   ASSERT_TRUE(MemoryAllocatorDump::Flags::WEAK & shared_mad2->flags());
   ASSERT_EQ(4u, pmd1->heap_dumps().size());
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd1/heap_dump1") != nullptr);
@@ skipping 141 matching lines @@
       static_cast<char*>(base::AlignedAlloc(kVeryLargeMemorySize, page_size)));
   memset(memory2.get(), 0, kVeryLargeMemorySize);
   size_t res2 = ProcessMemoryDump::CountResidentBytes(memory2.get(),
                                                       kVeryLargeMemorySize);
   ASSERT_EQ(res2, kVeryLargeMemorySize);
 }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 
 }  // namespace trace_event
 }  // namespace base