[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_allocation_context.h

Index: base/trace_event/heap_profiler_allocation_context.h
diff --git a/base/trace_event/heap_profiler_allocation_context.h b/base/trace_event/heap_profiler_allocation_context.h
index 8544c78eb2cd34c3f7693fa4063ccdcf85f837a1..ef89ea6e459134414562969df069205f155cd52d 100644
--- a/base/trace_event/heap_profiler_allocation_context.h
+++ b/base/trace_event/heap_profiler_allocation_context.h
@@ -35,10 +35,40 @@ namespace trace_event {
 //
 // 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.
@@ -83,6 +113,11 @@ bool BASE_EXPORT operator==(const AllocationContext& lhs,
 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;
 };