[tracing] Add native allocation tracing mode.

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.
 
-using StackFrame = const char*;
+// TODO: description

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

:)

+struct BASE_EXPORT StackFrame {
+  enum Type {

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

enum class (thanks c++11), so we can get the right scoping and avoid TYPE_
prefix.

+    TYPE_SYMBOL,        // const char* string

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

Is this for the pseudo stack?
In this case I think it should be 
TRACE_EVENT_NAME

+    TYPE_THREAD_NAME,   // const char* thread name
+    TYPE_PC,            // as returned by stack tracing (e.g. by StackTrace)

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

Let's call it explicitly PROGRAM_COUNTER (or NATIVE_FRAME).
Also I guess you meant "by stack unwinding" in the comment

+  };
+
+  bool empty() const { return value == nullptr; }
+
+  static StackFrame Empty() {
+    return {TYPE_SYMBOL, nullptr};
+  }
+
+  static StackFrame FromSymbol(const void* symbol) {
+    return {TYPE_SYMBOL, symbol};
+  }
+  static StackFrame FromPC(const void* pc) {
+    return {TYPE_PC, pc};
+  }
+  static StackFrame FromThreadName(const char* name) {
+    return {TYPE_THREAD_NAME, name};
+  }
+
+  Type type;
+  const void* value;
+};
+
+bool BASE_EXPORT operator < (const StackFrame& lhs, const StackFrame& rhs);

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

what do we need these operators for?

[Dmitry Skiba, 2016/04/12 18:22:10]

For inserting StackFrame in a map, deduplicator does that.

+bool BASE_EXPORT operator == (const StackFrame& lhs, const StackFrame& rhs);
+bool BASE_EXPORT operator != (const StackFrame& lhs, const StackFrame& rhs);
 
 struct BASE_EXPORT Backtrace {
-  // Unused backtrace frames are filled with nullptr frames. If the stack is
+  // Unused backtrace frames are filled with empty 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 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-
@@ skipping 24 matching lines @@
 
 bool BASE_EXPORT operator==(const AllocationContext& lhs,
                             const AllocationContext& rhs);
 
 }  // namespace trace_event
 }  // namespace base
 
 namespace BASE_HASH_NAMESPACE {
 
 template <>
+struct BASE_EXPORT hash<base::trace_event::StackFrame>: hash<const void*> {

[Primiano Tucci (use gerrit), 2016/04/07 15:51:56]

where do we hash StackFrame objects? Don't we keep them just in a flat array?

[Dmitry Skiba, 2016/04/12 18:22:10]

Just in case someone decides to put it into a hash map. Without hash
specialization one might chose tree map just because operator< is available and
he/she doesn't want to mess with implementing a hash.

+  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_