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 207 matching lines @@
     trace_event_internal::TraceID::DontMangle(id)
 
 // Records a pair of begin and end events called "name" for the current
 // 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_EVENT_WITH_FLOW0(category_group, name, bind_id, flow_direction) \
+  INTERNAL_TRACE_MEMORY(category_group, name)                                 \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id,    \
+                                            flow_direction)
 #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_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_direction, \
+                               arg1_name, arg1_val)                           \
+  INTERNAL_TRACE_MEMORY(category_group, name)                                 \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(                                  \
+      category_group, name, bind_id, flow_direction, 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_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_direction, \
+                               arg1_name, arg1_val, arg2_name, arg2_val)      \
+  INTERNAL_TRACE_MEMORY(category_group, name)                                 \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id,    \
+                                            flow_direction, 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)
 
+#define TRACE_EVENT_WITH_MEMORY_TAG_WITH_FLOW2(category, name, memory_tag,     \
+                                               bind_id, flow_direction,        \
+                                               arg1_name, arg1_val, arg2_name, \
+                                               arg2_val)                       \
+  INTERNAL_TRACE_MEMORY(category, memory_tag)                                  \
+  INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category, name, bind_id,           \
+                                            flow_direction, arg1_name,         \
+                                            arg1_val, arg2_name, arg2_val)
+
 // UNSHIPPED_TRACE_EVENT* are like TRACE_EVENT* except that they are not
 // included in official builds.
 
 #if OFFICIAL_BUILD
 #undef TRACING_IS_OFFICIAL_BUILD
 #define TRACING_IS_OFFICIAL_BUILD 1
 #elif !defined(TRACING_IS_OFFICIAL_BUILD)
 #define TRACING_IS_OFFICIAL_BUILD 0
 #endif
 
@@ skipping 787 matching lines @@
 
 #define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group) \
     static TRACE_EVENT_API_ATOMIC_WORD INTERNAL_TRACE_EVENT_UID(atomic) = 0; \
     const unsigned char* INTERNAL_TRACE_EVENT_UID(category_group_enabled); \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(category_group, \
         INTERNAL_TRACE_EVENT_UID(atomic), \
         INTERNAL_TRACE_EVENT_UID(category_group_enabled));
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...) \
-    do { \
-      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
-      if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        trace_event_internal::AddTraceEvent( \
-            phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
-            trace_event_internal::kNoEventId, flags, ##__VA_ARGS__); \
-      } \
-    } while (0)
+#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...)   \

[dsinclair, 2015/07/17 13:39:40]

Can you undo the formatting that puts the \'s lined up? It makes it harder to
see what actually changed.

+  do {                                                                      \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+      trace_event_internal::AddTraceEvent(                                  \
+          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,    \
+          trace_event_internal::kNoEventId, flags,                          \
+          trace_event_internal::kNoBindId, ##__VA_ARGS__);                  \
+    }                                                                       \
+  } while (0)
 
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
 // ends.
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...) \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
-    trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-      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(category_group, name, ...)        \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
+  trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);    \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+    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,      \
+            trace_event_internal::kNoBindId, ##__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, bind_id, flow_direction, ...)                    \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
+  trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);     \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
+    unsigned int trace_event_flags = flow_direction;                       \
+    trace_event_internal::TraceID trace_event_bind_id(bind_id,             \
+                                                      &trace_event_flags); \
+    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, flow_direction,              \
+            trace_event_bind_id.data(), ##__VA_ARGS__);                    \
+    INTERNAL_TRACE_EVENT_UID(tracer).Initialize(                           \
+        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h);        \
+  }
 
 // 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 int 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(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 int 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,                     \
+          trace_event_internal::kNoBindId, ##__VA_ARGS__);                    \
+    }                                                                         \
+  } while (0)
 
 // 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 int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
-        trace_event_internal::TraceID trace_event_trace_id( \
-            id, &trace_event_flags); \
-        trace_event_internal::AddTraceEventWithThreadIdAndTimestamp( \
-            phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
-            name, trace_event_trace_id.data(), \
-            thread_id, base::TraceTicks::FromInternalValue(timestamp), \
-            trace_event_flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP, \
-            ##__VA_ARGS__); \
-      } \
-    } while (0)
+#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 int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;       \
+      trace_event_internal::TraceID trace_event_trace_id(id,                  \
+                                                         &trace_event_flags); \
+      trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(            \
+          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,      \
+          trace_event_trace_id.data(), thread_id,                             \
+          base::TraceTicks::FromInternalValue(timestamp),                     \
+          trace_event_flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,            \
+          trace_event_internal::kNoBindId, ##__VA_ARGS__);                    \
+    }                                                                         \
+  } while (0)
 
 // Notes regarding the following definitions:
 // New values can be added and propagated to third party libraries, but existing
 // definitions must never be changed, because third party libraries may use old
 // definitions.
 
 // Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
 #define TRACE_EVENT_PHASE_BEGIN    ('B')
 #define TRACE_EVENT_PHASE_END      ('E')
 #define TRACE_EVENT_PHASE_COMPLETE ('X')
@@ skipping 19 matching lines @@
 // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
 #define TRACE_EVENT_FLAG_NONE         (static_cast<unsigned int>(0))
 #define TRACE_EVENT_FLAG_COPY         (static_cast<unsigned int>(1 << 0))
 #define TRACE_EVENT_FLAG_HAS_ID       (static_cast<unsigned int>(1 << 1))
 #define TRACE_EVENT_FLAG_MANGLE_ID    (static_cast<unsigned int>(1 << 2))
 #define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 3))
 #define TRACE_EVENT_FLAG_SCOPE_EXTRA  (static_cast<unsigned int>(1 << 4))
 #define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 5))
 #define TRACE_EVENT_FLAG_ASYNC_TTS    (static_cast<unsigned int>(1 << 6))
 #define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 7))
+#define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 8))
+#define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 9))

[dsinclair, 2015/07/17 13:39:40]

nit: Can you line the ('s up on these ones with ASYNC_TTS (static above.

 
 #define TRACE_EVENT_FLAG_SCOPE_MASK   (static_cast<unsigned int>( \
     TRACE_EVENT_FLAG_SCOPE_OFFSET | TRACE_EVENT_FLAG_SCOPE_EXTRA))
 
 // Type values for identifying types in the TraceValue union.
 #define TRACE_VALUE_TYPE_BOOL         (static_cast<unsigned char>(1))
 #define TRACE_VALUE_TYPE_UINT         (static_cast<unsigned char>(2))
 #define TRACE_VALUE_TYPE_INT          (static_cast<unsigned char>(3))
 #define TRACE_VALUE_TYPE_DOUBLE       (static_cast<unsigned char>(4))
 #define TRACE_VALUE_TYPE_POINTER      (static_cast<unsigned char>(5))
@@ skipping 10 matching lines @@
 #define TRACE_EVENT_SCOPE_NAME_GLOBAL  ('g')
 #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
 #define TRACE_EVENT_SCOPE_NAME_THREAD  ('t')
 
 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;
+const unsigned long long kNoBindId = 0;

[dsinclair, 2015/07/17 13:39:40]

Let's just rename kNoEventId to kNoId = 0 and use it for both of them.

 
 // 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.
 class TraceID {
  public:
   class DontMangle {
    public:
     explicit DontMangle(const void* id)
         : data_(static_cast<unsigned long long>(
@@ skipping 193 matching lines @@
 
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
         arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1] = { TRACE_VALUE_TYPE_CONVERTABLE };
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, &arg1_name, arg_types, NULL, &arg1_val, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      &arg1_name, arg_types, NULL, &arg1_val, flags, bind_id);
 }
 
-template<class ARG1_TYPE>
+template <class ARG1_TYPE>
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     const char* arg2_name,
     const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
         arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
 
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   arg_types[1] = TRACE_VALUE_TYPE_CONVERTABLE;
 
   scoped_refptr<base::trace_event::ConvertableToTraceFormat>
       convertable_values[2];
   convertable_values[1] = arg2_val;
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, arg_names, arg_types, arg_values, convertable_values, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      arg_names, arg_types, arg_values, convertable_values, flags, bind_id);
 }
 
-template<class ARG2_TYPE>
+template <class ARG2_TYPE>

[dsinclair, 2015/07/17 13:39:40]

nit: remove space.

 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const scoped_refptr<base::trace_event::ConvertableToTraceFormat>& arg1_val,
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
 
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   arg_types[0] = TRACE_VALUE_TYPE_CONVERTABLE;
   arg_values[0] = 0;
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
 
   scoped_refptr<base::trace_event::ConvertableToTraceFormat>
       convertable_values[2];
   convertable_values[0] = arg1_val;
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, arg_names, arg_types, arg_values, convertable_values, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      arg_names, arg_types, arg_values, convertable_values, flags, bind_id);
 }
 
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const scoped_refptr<base::trace_event::ConvertableToTraceFormat>& arg1_val,
     const char* arg2_name,
     const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
         arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
   unsigned char arg_types[2] =
       { TRACE_VALUE_TYPE_CONVERTABLE, TRACE_VALUE_TYPE_CONVERTABLE };
   scoped_refptr<base::trace_event::ConvertableToTraceFormat>
       convertable_values[2] = {arg1_val, arg2_val};
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, arg_names, arg_types, NULL, convertable_values, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      arg_names, arg_types, NULL, convertable_values, flags, bind_id);
 }
 
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
-    unsigned int flags) {
+    unsigned int flags,
+    unsigned long long bind_id) {

[dsinclair, 2015/07/17 13:39:40]

Let's move bind_id up below int thread_id so we keep the various id's together.

   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
-      kZeroNumArgs, NULL, NULL, NULL, NULL, flags);
+      kZeroNumArgs, NULL, NULL, NULL, NULL, flags, bind_id);
 }
 
 static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
-    unsigned int flags) {
+    unsigned int flags,
+    unsigned long long bind_id) {
   const int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   const base::TraceTicks now = base::TraceTicks::Now();
-  return AddTraceEventWithThreadIdAndTimestamp(phase, category_group_enabled,
-                                               name, id, thread_id, now, flags);
+  return AddTraceEventWithThreadIdAndTimestamp(
+      phase, category_group_enabled, name, id, thread_id, now, flags, bind_id);
 }
 
-template<class ARG1_TYPE>
+template <class ARG1_TYPE>
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1];
   unsigned long long arg_values[1];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, &arg1_name, arg_types, arg_values, NULL, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      &arg1_name, arg_types, arg_values, NULL, flags, bind_id);
 }
 
-template<class ARG1_TYPE>
+template <class ARG1_TYPE>
 static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const ARG1_TYPE& arg1_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);
+                                               bind_id, arg1_name, arg1_val);
 }
 
-template<class ARG1_TYPE, class ARG2_TYPE>
+template <class ARG1_TYPE, class ARG2_TYPE>
 static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TraceTicks& timestamp,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-      phase, category_group_enabled, name, id, thread_id, timestamp,
-      num_args, arg_names, arg_types, arg_values, NULL, flags);
+      phase, category_group_enabled, name, id, thread_id, timestamp, num_args,
+      arg_names, arg_types, arg_values, NULL, flags, bind_id);
 }
 
-template<class ARG1_TYPE, class ARG2_TYPE>
+template <class ARG1_TYPE, class ARG2_TYPE>
 static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     unsigned int flags,
+    unsigned long long bind_id,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     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);
+  return AddTraceEventWithThreadIdAndTimestamp(
+      phase, category_group_enabled, name, id, thread_id, now, flags, bind_id,
+      arg1_name, arg1_val, arg2_name, arg2_val);
 }
 
 // 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)
@@ skipping 105 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_