Implement a new flow event API that allows binding flow events and regular events.

base/trace_event/trace_event.h

 // Copyright (c) 2012 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.
 
 // This header file defines the set of trace_event macros without specifying
 // how the events actually get collected and stored. If you need to expose trace
 // events to some other universe, you can copy-and-paste this file as well as
 // trace_event.h, modifying the macros contained there as necessary for the
 // target platform. The end result is that multiple libraries can funnel events
 // through to a shared trace event collector.
@@ skipping 210 matching lines @@
 // scope, with 0, 1 or 2 associated arguments. If the category is not
 // enabled, then this does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT0(category_group, name) \
     INTERNAL_TRACE_MEMORY(category_group, name) \
     INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
 #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
     INTERNAL_TRACE_MEMORY(category_group, name) \
     INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
+#define TRACE_EVENT1_WITH_FLOW(category_group, name, arg1_name, arg1_val) \

[dsinclair, 2015/07/14 13:52:10]

These should be TRACE_EVENT_WITH_FLOW1

We put the numbers at the end of all the macros.

+    INTERNAL_TRACE_MEMORY(category_group, name) \
+    INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, arg1_name, arg1_val)
 #define TRACE_EVENT2( \
     category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_MEMORY(category_group, name) \
   INTERNAL_TRACE_EVENT_ADD_SCOPED( \
       category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT2_WITH_FLOW( \

[dsinclair, 2015/07/14 13:52:10]

Why no TRACE_EVENT_WITH_FLOW0?

+    category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \
+  INTERNAL_TRACE_MEMORY(category_group, name) \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW( \
+      category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
 
 // Records events like TRACE_EVENT2 but uses |memory_tag| for memory tracing.
 // Use this where |name| is too generic to accurately aggregate allocations.
 #define TRACE_EVENT_WITH_MEMORY_TAG2( \
     category, name, memory_tag, arg1_name, arg1_val, arg2_name, arg2_val) \
   INTERNAL_TRACE_MEMORY(category, memory_tag) \
   INTERNAL_TRACE_EVENT_ADD_SCOPED( \
       category, name, arg1_name, arg1_val, arg2_name, arg2_val)
 
 // UNSHIPPED_TRACE_EVENT* are like TRACE_EVENT* except that they are not
@@ skipping 599 matching lines @@
         arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
         category_group, name, id, TRACE_EVENT_FLAG_COPY, "step", step, \
         arg1_name, arg1_val)
 
 // Records a single FLOW_END event for "name" immediately. If the category
 // is not enabled, then this does nothing.
 #define TRACE_EVENT_FLOW_END0(category_group, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE)
+#define APPEND_TRACE_EVENT_FLOW_END0(category_group, name, id) \
+    appendFlowEvent(trace_event_internal::constructFlowEvent(TRACE_EVENT_PHASE_FLOW_END, \
+        category_group, name, id, TRACE_EVENT_FLAG_NONE))
 #define TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0(category_group, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
         category_group, name, id, TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
 #define TRACE_EVENT_FLOW_END1(category_group, name, id, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
 #define TRACE_EVENT_FLOW_END2(category_group, name, id, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE, \
@@ skipping 204 matching lines @@
       base::trace_event::TraceEventHandle h = \
           trace_event_internal::AddTraceEvent( \
               TRACE_EVENT_PHASE_COMPLETE, \
               INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
               trace_event_internal::kNoEventId, TRACE_EVENT_FLAG_NONE, \
               ##__VA_ARGS__); \
       INTERNAL_TRACE_EVENT_UID(tracer).Initialize( \
           INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h); \
     }
 
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, ...) \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+    trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
+    base::trace_event::TraceEventHandle h = {0, 0, 0}; \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+      h = trace_event_internal::AddTraceEvent( \
+          TRACE_EVENT_PHASE_COMPLETE, \
+          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+          trace_event_internal::kNoEventId, TRACE_EVENT_FLAG_NONE, \
+          ##__VA_ARGS__); \
+      INTERNAL_TRACE_EVENT_UID(tracer).Initialize( \
+          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h); \
+    } \
+    base::trace_event::TraceEventHandleWrapper INTERNAL_TRACE_EVENT_UID(wrapper) (h); \
+    INTERNAL_TRACE_EVENT_UID(wrapper)
+
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id, \
                                          flags, ...) \
     do { \
       INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
       if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
         unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
         trace_event_internal::TraceID trace_event_trace_id( \
             id, &trace_event_flags); \
         trace_event_internal::AddTraceEvent( \
             phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
             name, trace_event_trace_id.data(), trace_event_flags, \
             ##__VA_ARGS__); \
       } \
     } while (0)
 
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_RETURN(phase, category_group, name, id, \
+                                         flags, ...) \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+      unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
+      trace_event_internal::TraceID trace_event_trace_id( \
+          id, &trace_event_flags); \
+      return trace_event_internal::AddTraceEvent( \
+          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
+          name, trace_event_trace_id.data(), trace_event_flags, \
+          ##__VA_ARGS__); \
+    } \
+    base::trace_event::TraceEventHandle h = {0, 0, 0}; \
+    return h;
+
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(phase, \
         category_group, name, id, thread_id, timestamp, flags, ...) \
     do { \
       INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
       if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
         unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
         trace_event_internal::TraceID trace_event_trace_id( \
             id, &trace_event_flags); \
@@ skipping 61 matching lines @@
 // Enum reflecting the scope of an INSTANT event. Must fit within
 // TRACE_EVENT_FLAG_SCOPE_MASK.
 #define TRACE_EVENT_SCOPE_GLOBAL  (static_cast<unsigned char>(0 << 3))
 #define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3))
 #define TRACE_EVENT_SCOPE_THREAD  (static_cast<unsigned char>(2 << 3))
 
 #define TRACE_EVENT_SCOPE_NAME_GLOBAL  ('g')
 #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
 #define TRACE_EVENT_SCOPE_NAME_THREAD  ('t')
 
+// Type values for identifying flow event direction.
+#define FLOW_IN (static_cast<unsigned char>(0))
+#define FLOW_OUT (static_cast<unsigned char>(1))

[dsinclair, 2015/07/14 13:52:10]

These should be TRACE_EVENT_FLAG_FLOW_IN/OUT. fmeawad@ has a Cl to extend the
unsigned char to a unsigned int.

[fmeawad, 2015/07/14 17:32:57]

The CL has landed.

+
 namespace trace_event_internal {
 
 // Specify these values when the corresponding argument of AddTraceEvent is not
 // used.
 const int kZeroNumArgs = 0;
 const unsigned long long kNoEventId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
 // are by default mangled with the Process ID so that they are unlikely to
 // collide when the same pointer is used on different processes.
@@ skipping 406 matching lines @@
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   base::TraceTicks now = base::TraceTicks::Now();
   return AddTraceEventWithThreadIdAndTimestamp(phase, category_group_enabled,
                                                name, id, thread_id, now, flags,
                                                arg1_name, arg1_val,
                                                arg2_name, arg2_val);
 }
 
+static inline base::trace_event::TraceEventHandle constructFlowEvent(
+    char phase,
+    const char *category_group,
+    const char *name,
+    unsigned long long id,
+    unsigned char flags) {
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID_RETURN(phase, category_group, name, id, flags);
+}
+
 // Used by TRACE_EVENTx macros. Do not use directly.
 class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
  public:
   // Note: members of data_ intentionally left uninitialized. See Initialize.
   ScopedTracer() : p_data_(NULL) {}
 
   ~ScopedTracer() {
     if (p_data_ && *data_.category_group_enabled)
       TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
           data_.category_group_enabled, data_.name, data_.event_handle);
@@ skipping 103 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_