[Tracing] Introduce HeapDumpWriter helper class

base/trace_event/memory_profiler_allocation_context_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/memory_profiler_allocation_context.h"
 #include "base/trace_event/trace_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
@@ skipping 213 matching lines @@
   }
 
   {
     AllocationContext ctx = AllocationContextTracker::GetContextSnapshot();
     ASSERT_EQ(kCupcake, ctx.backtrace.frames[0]);
     ASSERT_EQ(kFroyo, ctx.backtrace.frames[11]);
   }
 }
 
 TEST_F(StackFrameDeduplicatorTest, SingleBacktrace) {
-  AllocationContext::Backtrace bt = {
+  Backtrace bt = {

[Primiano Tucci (use gerrit), 2015/10/26 11:52:06]

If the problem is breaking lines here you can just add a "using" on top of this
file

[Ruud van Asseldonk, 2015/10/26 14:51:26]

That is what I did at first but then I though I might as well extract the class
instead of adding the using everywhere.

       {kBrowserMain, kCreateWidget, kMalloc, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
 
   // The call tree should look like this (index in brackets).
   //
   // BrowserMain [0]
   // + CreateWidget [1]
   //   + malloc [2]
 
   StackFrameDeduplicator dedup;
   ASSERT_EQ(2, dedup.Insert(bt));
 
   auto iter = dedup.begin();
   ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
   ASSERT_EQ(-1, (iter + 0)->parent_frame_index);
 
   ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
   ASSERT_EQ(0, (iter + 1)->parent_frame_index);
 
   ASSERT_EQ(kMalloc, (iter + 2)->frame);
   ASSERT_EQ(1, (iter + 2)->parent_frame_index);
 
   ASSERT_EQ(iter + 3, dedup.end());
 }
 
 // Test that there can be different call trees (there can be multiple bottom
 // frames). Also verify that frames with the same name but a different caller
 // are represented as distinct nodes.
 TEST_F(StackFrameDeduplicatorTest, MultipleRoots) {
-  AllocationContext::Backtrace bt0 = {
-      {kBrowserMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
-  AllocationContext::Backtrace bt1 = {
-      {kRendererMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  Backtrace bt0 = {{kBrowserMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  Backtrace bt1 = {{kRendererMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
 
   // The call tree should look like this (index in brackets).
   //
   // BrowserMain [0]
   // + CreateWidget [1]
   // RendererMain [2]
   // + CreateWidget [3]
   //
   // Note that there will be two instances of Donut, with different parents.
 
@@ skipping 11 matching lines @@
   ASSERT_EQ(kRendererMain, (iter + 2)->frame);
   ASSERT_EQ(-1, (iter + 2)->parent_frame_index);
 
   ASSERT_EQ(kCreateWidget, (iter + 3)->frame);
   ASSERT_EQ(2, (iter + 3)->parent_frame_index);
 
   ASSERT_EQ(iter + 4, dedup.end());
 }
 
 TEST_F(StackFrameDeduplicatorTest, Deduplication) {
-  AllocationContext::Backtrace bt0 = {
-      {kBrowserMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
-  AllocationContext::Backtrace bt1 = {
-      {kBrowserMain, kInitialize, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  Backtrace bt0 = {{kBrowserMain, kCreateWidget, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+  Backtrace bt1 = {{kBrowserMain, kInitialize, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
 
   // The call tree should look like this (index in brackets).
   //
   // BrowserMain [0]
   // + CreateWidget [1]
   // + Initialize [2]
   //
   // Note that Cupcake will be re-used.
 
   StackFrameDeduplicator dedup;
@@ skipping 14 matching lines @@
 
   // Inserting the same backtrace again should return the index of the existing
   // node.
   ASSERT_EQ(1, dedup.Insert(bt0));
   ASSERT_EQ(2, dedup.Insert(bt1));
   ASSERT_EQ(dedup.begin() + 3, dedup.end());
 }
 
 }  // namespace trace_event
 }  // namespace base