[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/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 {
 
 const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::DETAILED};
 const char* const kTestDumpNameWhitelist[] = {
     "Whitelisted/TestName", "Whitelisted/TestName_0x?",
     "Whitelisted/0x?/TestName", nullptr};
 
+#if 0

[Primiano Tucci (use gerrit), 2017/03/09 11:47:45]

uh? I think this is a leftover

[DmitrySkiba, 2017/03/14 22:12:48]

Done.

 TracedValue* GetHeapDump(const ProcessMemoryDump& pmd, const char* name) {
   auto it = pmd.heap_dumps().find(name);
   return it == pmd.heap_dumps().end() ? nullptr : it->second.get();
 }
+#endif
 
 }  // namespace
 
 TEST(ProcessMemoryDumpTest, Clear) {
   std::unique_ptr<ProcessMemoryDump> pmd1(
       new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
   pmd1->CreateAllocatorDump("mad1");
   pmd1->CreateAllocatorDump("mad2");
   ASSERT_FALSE(pmd1->allocator_dumps().empty());
 
@@ skipping 40 matching lines @@
   ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
   ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
   ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad2->flags());
 
   traced_value.reset(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
+#if 0

[Primiano Tucci (use gerrit), 2017/03/09 11:47:45]

ditto

[DmitrySkiba, 2017/03/14 22:12:48]

Done.

 TEST(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
   hash_map<AllocationContext, AllocationMetrics> metrics_by_context;
   metrics_by_context[AllocationContext()] = { 1, 1 };
   TraceEventMemoryOverhead overhead;
 
   scoped_refptr<MemoryDumpSessionState> session_state =
       new MemoryDumpSessionState;
   session_state->SetStackFrameDeduplicator(
       WrapUnique(new StackFrameDeduplicator));
@@ skipping 55 matching lines @@
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd1/heap_dump2") != nullptr);
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump1") != nullptr);
   ASSERT_TRUE(GetHeapDump(*pmd1, "pmd2/heap_dump2") != nullptr);
 
   // Check that calling AsValueInto() doesn't cause a crash.
   traced_value.reset(new TracedValue);
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
+#endif
 
 TEST(ProcessMemoryDumpTest, Suballocations) {
   std::unique_ptr<ProcessMemoryDump> pmd(
       new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
   const std::string allocator_dump_name = "fakealloc/allocated_objects";
   pmd->CreateAllocatorDump(allocator_dump_name);
 
   // Create one allocation with an auto-assigned guid and mark it as a
   // suballocation of "fakealloc/allocated_objects".
   auto* pic1_dump = pmd->CreateAllocatorDump("picturemanager/picture1");
@@ skipping 121 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