Revert of [tracing] Turn StackFrame into struct.

base/trace_event/heap_profiler_allocation_context.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 // The number of stack frames stored in the backtrace is a trade off between
 // memory used for tracing and accuracy. Measurements done on a prototype
 // revealed that:
 //
 // - In 60 percent of the cases, stack depth <= 7.
 // - In 87 percent of the cases, stack depth <= 9.
 // - In 95 percent of the cases, stack depth <= 11.
 //
 // See the design doc (https://goo.gl/4s7v7b) for more details.
 
-// Represents (pseudo) stack frame. Used in Backtrace class below.
-//
-// Conceptually stack frame is identified by its value, and type is used
-// mostly to properly format the value. Value is expected to be a valid
-// pointer from process' address space.
-struct BASE_EXPORT StackFrame {
-  enum class Type {
-    TRACE_EVENT_NAME,   // const char* string
-    THREAD_NAME,        // const char* thread name
-  };
+using StackFrame = const char*;
 
-  static StackFrame FromTraceEventName(const char* name) {
-    return {Type::TRACE_EVENT_NAME, name};
-  }
-  static StackFrame FromThreadName(const char* name) {
-    return {Type::THREAD_NAME, name};
-  }
-
-  Type type;
-  const void* value;
+struct BASE_EXPORT Backtrace {
+  // Unused backtrace frames are filled with nullptr frames. If the stack is
+  // higher than what can be stored here, the bottom frames are stored. Based
+  // on the data above, a depth of 12 captures the full stack in the vast
+  // majority of the cases.
+  StackFrame frames[12];
 };
 
-bool BASE_EXPORT operator < (const StackFrame& lhs, const StackFrame& rhs);
-bool BASE_EXPORT operator == (const StackFrame& lhs, const StackFrame& rhs);
-bool BASE_EXPORT operator != (const StackFrame& lhs, const StackFrame& rhs);
-
-struct BASE_EXPORT Backtrace {
-  Backtrace();
-
-  // If the stack is higher than what can be stored here, the bottom frames
-  // (the ones closer to main()) are stored. Based on the data above, a depth
-  // of 12 captures the full stack in the vast majority of the cases.
-  enum { kMaxFrameCount = 12 };
-  StackFrame frames[kMaxFrameCount];
-  size_t frame_count;
+// Struct to store the size and count of the allocations.
+struct AllocationMetrics {
+  size_t size;
+  size_t count;
 };
 
 bool BASE_EXPORT operator==(const Backtrace& lhs, const Backtrace& rhs);
 
 // The |AllocationContext| is context metadata that is kept for every allocation
 // when heap profiling is enabled. To simplify memory management for book-
-// keeping, this struct has a fixed size.
+// keeping, this struct has a fixed size. All |const char*|s here must have
+// static lifetime.
 struct BASE_EXPORT AllocationContext {
-  AllocationContext();
+ public:
+  // An allocation context with empty backtrace and unknown type.
+  static AllocationContext Empty();
 
   Backtrace backtrace;
 
   // Type name of the type stored in the allocated memory. A null pointer
   // indicates "unknown type". Grouping is done by comparing pointers, not by
   // deep string comparison. In a component build, where a type name can have a
   // string literal in several dynamic libraries, this may distort grouping.
   const char* type_name;
+
+ private:
+  friend class AllocationContextTracker;
+
+  // Don't allow uninitialized instances except inside the allocation context
+  // tracker. Except in tests, an |AllocationContext| should only be obtained
+  // from the tracker. In tests, paying the overhead of initializing the struct
+  // to |Empty| and then overwriting the members is not such a big deal.
+  AllocationContext();
 };
 
 bool BASE_EXPORT operator==(const AllocationContext& lhs,
                             const AllocationContext& rhs);
 
-// Struct to store the size and count of the allocations.
-struct AllocationMetrics {
-  size_t size;
-  size_t count;
-};
-
 }  // namespace trace_event
 }  // namespace base
 
 namespace BASE_HASH_NAMESPACE {
 
 template <>
-struct BASE_EXPORT hash<base::trace_event::StackFrame> {
-  size_t operator()(const base::trace_event::StackFrame& frame) const;
-};
-
-template <>
 struct BASE_EXPORT hash<base::trace_event::Backtrace> {
   size_t operator()(const base::trace_event::Backtrace& backtrace) const;
 };
 
 template <>
 struct BASE_EXPORT hash<base::trace_event::AllocationContext> {
   size_t operator()(const base::trace_event::AllocationContext& context) const;
 };
 
 }  // BASE_HASH_NAMESPACE
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_