[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_allocation_context_tracker.h

Index: base/trace_event/heap_profiler_allocation_context_tracker.h
diff --git a/base/trace_event/heap_profiler_allocation_context_tracker.h b/base/trace_event/heap_profiler_allocation_context_tracker.h
index d6133323bfb3d8f88f4331f6c718582c5611b3ee..202bd8914b9964facce371f12a8a7abf26307d8d 100644
--- a/base/trace_event/heap_profiler_allocation_context_tracker.h
+++ b/base/trace_event/heap_profiler_allocation_context_tracker.h
@@ -23,24 +23,29 @@ namespace trace_event {
 // details.
 class BASE_EXPORT AllocationContextTracker {
  public:
-  // Globally enables capturing allocation context.
-  // TODO(ruuda): Should this be replaced by |EnableCapturing| in the future?
-  // Or at least have something that guards agains enable -> disable -> enable?
-  static void SetCaptureEnabled(bool enabled);
+  enum CaptureMode {

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

enum class CaptureMode { DISABLED, PSEUDO_STACK, NATIVE_STACK }

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

Done.

+    DONT_CAPTURE = 0, // must be 0
+    CAPTURE_PSEUDO_STACK,
+    CAPTURE_NATIVE_STACK
+  };
+
+  // Globally sets capturing mode.
+  // TODO: How to guards against CAPTURE_* -> DONT_CAPTURE -> CAPTURE_*?

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

TODO want always a name ;)
you can put mine if you want, as ruuda@ is unlikely to address that TODO you are
removing.

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

Done.

+  static void SetCaptureMode(CaptureMode mode);
 
   // Returns whether capturing allocation context is enabled globally.
   inline static bool capture_enabled() {

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

Hmm I think you want to expose the capture mode here.
My rationale is: this is used by trace_log.cc to figure out if it should push
inside the tracer or not.
Right now with this CL you are letting it push the trace event in the tracker,
but you are never reading those events back in the GetSnapshot().
Is it intended? Is it because you want to later support both native and pseudo
stacks, and just didn't bother now?
Or is this not intended and you just didn't think to that?

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

Yes, this is intended. I want us to still maintain pseudo stack because we might
want to use it as a filter for native traces, i.e. report native stack only if
event X is on the pseudo stack. Basically I consider capturing mode an
implementation detail, which might change, and outside world should care only
about whether we are capturing or not.

Besides, we might need to maintain pseudo stack for other components, like v8.

     // A little lag after heap profiling is enabled or disabled is fine, it is
     // more important that the check is as cheap as possible when capturing is
     // not enabled, so do not issue a memory barrier in the fast path.
-    if (subtle::NoBarrier_Load(&capture_enabled_) == 0)
+    if (subtle::NoBarrier_Load(&capture_mode_) == DONT_CAPTURE)
       return false;
 
     // In the slow path, an acquire load is required to pair with the release
-    // store in |SetCaptureEnabled|. This is to ensure that the TLS slot for
+    // store in |SetCaptureMode|. This is to ensure that the TLS slot for
     // the thread-local allocation context tracker has been initialized if
     // |capture_enabled| returns true.
-    return subtle::Acquire_Load(&capture_enabled_) != 0;
+    return subtle::Acquire_Load(&capture_mode_) != DONT_CAPTURE;
   }
 
   // Returns the thread-local instance, creating one if necessary. Returns
@@ -53,10 +58,11 @@ class BASE_EXPORT AllocationContextTracker {
   static void SetCurrentThreadName(const char* name);
 
   // Pushes a frame onto the thread-local pseudo stack.
+  void PushPseudoStackFrame(const char* frame_symbol_value);

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

s/frame_symbol_value/trace_event_name/ :) it makes clear what the arg is

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

Done.

   void PushPseudoStackFrame(StackFrame frame);

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

Do we really need both versions here?
It seem that you still want the one that takes the char*.
Also, if you take a StackFrame this is not necessarily "pseudo" anymore, as it
could be native.

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

Done.

 
   // Pops a frame from the thread-local pseudo stack.
-  void PopPseudoStackFrame(StackFrame frame);
+  void PopPseudoStackFrame(const void* frame_value);
 
   // Push and pop current task's context. A stack is used to support nested
   // tasks and the top of the stack will be used in allocation context.
@@ -71,7 +77,7 @@ class BASE_EXPORT AllocationContextTracker {
  private:
   AllocationContextTracker();
 
-  static subtle::Atomic32 capture_enabled_;
+  static subtle::Atomic32 capture_mode_;
 
   // The pseudo stack where frames are |TRACE_EVENT| names.
   std::vector<StackFrame> pseudo_stack_;