[tracing] Turn StackFrame into struct.

base/trace_event/heap_profiler_heap_dump_writer_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/heap_profiler_heap_dump_writer.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
 #include "base/trace_event/heap_profiler_type_name_deduplicator.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+using base::trace_event::StackFrame;
+
 // Define all strings once, because the deduplicator requires pointer equality,
 // and string interning is unreliable.
-const char kBrowserMain[] = "BrowserMain";
-const char kRendererMain[] = "RendererMain";
-const char kCreateWidget[] = "CreateWidget";
-const char kInitialize[] = "Initialize";
-const char kGetBitmap[] = "GetBitmap";
+StackFrame kBrowserMain = StackFrame::FromTraceEventName("BrowserMain");
+StackFrame kRendererMain = StackFrame::FromTraceEventName("RendererMain");
+StackFrame kCreateWidget = StackFrame::FromTraceEventName("CreateWidget");
+StackFrame kInitialize = StackFrame::FromTraceEventName("Initialize");
+StackFrame kGetBitmap = StackFrame::FromTraceEventName("GetBitmap");
 
 const char kInt[] = "int";
 const char kBool[] = "bool";
 const char kString[] = "string";
 
 }  // namespace
 
 namespace base {
 namespace trace_event {
 namespace internal {
@@ skipping 129 matching lines @@
   ASSERT_EQ(large_value_str, size);
 
   std::string count;
   ASSERT_TRUE(json_entry->GetString("count", &count));
   ASSERT_EQ(large_value_str, count);
 }
 
 TEST(HeapDumpWriterTest, BacktraceTypeNameTable) {
   hash_map<AllocationContext, AllocationMetrics> metrics_by_context;
 
-  AllocationContext ctx = AllocationContext::Empty();
+  AllocationContext ctx;
   ctx.backtrace.frames[0] = kBrowserMain;
   ctx.backtrace.frames[1] = kCreateWidget;
+  ctx.backtrace.frame_count = 2;
   ctx.type_name = kInt;
 
   // 10 bytes with context { type: int, bt: [BrowserMain, CreateWidget] }.
   metrics_by_context[ctx] = {10, 5};
 
   ctx.type_name = kBool;
 
   // 18 bytes with context { type: bool, bt: [BrowserMain, CreateWidget] }.
   metrics_by_context[ctx] = {18, 18};
 
   ctx.backtrace.frames[0] = kRendererMain;
   ctx.backtrace.frames[1] = kInitialize;
+  ctx.backtrace.frame_count = 2;
 
   // 30 bytes with context { type: bool, bt: [RendererMain, Initialize] }.
   metrics_by_context[ctx] = {30, 30};
 
   ctx.type_name = kString;
 
   // 19 bytes with context { type: string, bt: [RendererMain, Initialize] }.
   metrics_by_context[ctx] = {19, 4};
 
   // At this point the heap looks like this:
@@ skipping 54 matching lines @@
 
   // The type breakdown of the entrie heap should have been dumped as well.
   AssertSizeAndCountEq(dump, -1, type_id_int, {10, 5});
   AssertSizeAndCountEq(dump, -1, type_id_bool, {48, 48});
   AssertSizeAndCountEq(dump, -1, type_id_string, {19, 4});
 }
 
 TEST(HeapDumpWriterTest, InsignificantValuesNotDumped) {
   hash_map<AllocationContext, AllocationMetrics> metrics_by_context;
 
-  AllocationContext ctx = AllocationContext::Empty();
+  AllocationContext ctx;
   ctx.backtrace.frames[0] = kBrowserMain;
   ctx.backtrace.frames[1] = kCreateWidget;
+  ctx.backtrace.frame_count = 2;
 
   // 0.5 KiB and 1 chunk in BrowserMain -> CreateWidget itself.
   metrics_by_context[ctx] = {512, 1};
 
   // 1 MiB and 1 chunk in BrowserMain -> CreateWidget -> GetBitmap.
   ctx.backtrace.frames[2] = kGetBitmap;
+  ctx.backtrace.frame_count = 3;
   metrics_by_context[ctx] = {1024 * 1024, 1};
 
   // 0.5 KiB and 1 chunk in BrowserMain -> CreateWidget -> Initialize.
   ctx.backtrace.frames[2] = kInitialize;
+  ctx.backtrace.frame_count = 3;
   metrics_by_context[ctx] = {512, 1};
 
   auto sf_deduplicator = WrapUnique(new StackFrameDeduplicator);
   auto tn_deduplicator = WrapUnique(new TypeNameDeduplicator);
   HeapDumpWriter writer(sf_deduplicator.get(), tn_deduplicator.get());
   const std::set<Entry>& dump = writer.Summarize(metrics_by_context);
 
   // Get the indices of the backtraces and types by adding them again to the
   // deduplicator. Because they were added before, the same number is returned.
   StackFrame bt0[] = {kBrowserMain, kCreateWidget, kGetBitmap};
@@ skipping 17 matching lines @@
                        {1024 * 1024 + 512 + 512, 3});
   AssertSizeAndCountEq(dump, bt_browser_main, -1, {1024 * 1024 + 512 + 512, 3});
 
   // Initialize was not significant, it should not have been dumped.
   AssertNotDumped(dump, bt_initialize, -1);
 }
 
 }  // namespace internal
 }  // namespace trace_event
 }  // namespace base