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

base/trace_event/trace_event_impl.cc

Index: base/trace_event/trace_event_impl.cc
diff --git a/base/trace_event/trace_event_impl.cc b/base/trace_event/trace_event_impl.cc
index cd8cf4aa90c46e7167682715b3a8f91618dfbd97..bfefe5229cf4fbe85f1b2e8491913ac1e19daa07 100644
--- a/base/trace_event/trace_event_impl.cc
+++ b/base/trace_event/trace_event_impl.cc
@@ -407,13 +407,11 @@ void InitializeMetadataEvent(TraceEvent* trace_event,
   unsigned char arg_type;
   unsigned long long arg_value;
   ::trace_event_internal::SetTraceValue(value, &arg_type, &arg_value);
-  trace_event->Initialize(thread_id,
-                          TraceTicks(), ThreadTicks(),
-                          TRACE_EVENT_PHASE_METADATA,
-                          &g_category_group_enabled[g_category_metadata],
-                          metadata_name, ::trace_event_internal::kNoEventId,
-                          num_args, &arg_name, &arg_type, &arg_value, NULL,
-                          TRACE_EVENT_FLAG_NONE);
+  trace_event->Initialize(
+      thread_id, TraceTicks(), ThreadTicks(), TRACE_EVENT_PHASE_METADATA,
+      &g_category_group_enabled[g_category_metadata], metadata_name,
+      ::trace_event_internal::kNoId, trace_event_internal::kNoId, num_args,
+      &arg_name, &arg_type, &arg_value, NULL, TRACE_EVENT_FLAG_NONE);
 }
 
 class AutoThreadLocalBoolean {
@@ -592,6 +590,7 @@ void TraceEvent::Initialize(
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
+    unsigned long long bind_id,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
@@ -607,6 +606,7 @@ void TraceEvent::Initialize(
   thread_id_ = thread_id;
   phase_ = phase;
   flags_ = flags;
+  bind_id_ = bind_id;
 
   // Clamp num_args since it may have been set by a third_party library.
   num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
@@ -848,6 +848,16 @@ void TraceEvent::AppendAsJSON(
   if (flags_ & TRACE_EVENT_FLAG_BIND_TO_ENCLOSING)
     StringAppendF(out, ",\"bp\":\"e\"");
 
+  if ((flags_ & TRACE_EVENT_FLAG_FLOW_OUT) ||
+      (flags_ & TRACE_EVENT_FLAG_FLOW_IN))
+    StringAppendF(out, ",\"bind_id\":\"0x%" PRIx64 "\"", static_cast<uint64>(bind_id_));
+
+  if (flags_ & TRACE_EVENT_FLAG_FLOW_IN)
+    StringAppendF(out, ",\"flow_in\":\"true\"");
+
+  if (flags_ & TRACE_EVENT_FLAG_FLOW_OUT)
+    StringAppendF(out, ",\"flow_out\":\"true\"");
+
   // Instant events also output their scope.
   if (phase_ == TRACE_EVENT_PHASE_INSTANT) {
     char scope = '?';
@@ -1208,11 +1218,10 @@ void TraceLog::ThreadLocalEventBuffer::ReportOverhead(
     TraceEvent* trace_event = AddTraceEvent(NULL);
     if (trace_event) {
       trace_event->Initialize(
-          static_cast<int>(PlatformThread::CurrentId()),
-          event_timestamp, event_thread_timestamp,
-          TRACE_EVENT_PHASE_COMPLETE,
+          static_cast<int>(PlatformThread::CurrentId()), event_timestamp,
+          event_thread_timestamp, TRACE_EVENT_PHASE_COMPLETE,
           &g_category_group_enabled[g_category_trace_event_overhead],
-          "overhead", 0, 0, NULL, NULL, NULL, NULL, 0);
+          "overhead", 0, trace_event_internal::kNoId, 0, NULL, NULL, NULL, NULL, 0);
       trace_event->UpdateDuration(now, thread_now);
     }
   }
@@ -2010,11 +2019,9 @@ TraceEventHandle TraceLog::AddTraceEvent(
     unsigned int flags) {
   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,
-                                               num_args, arg_names,
-                                               arg_types, arg_values,
-                                               convertable_values, flags);
+  return AddTraceEventWithThreadIdAndTimestamp(
+      phase, category_group_enabled, name, id, thread_id, trace_event_internal::kNoId,
+      now, num_args, arg_names, arg_types, arg_values, convertable_values, flags);
 }
 
 TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
@@ -2023,6 +2030,7 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
     const char* name,
     unsigned long long id,
     int thread_id,
+    unsigned long long bind_id,
     const TraceTicks& timestamp,
     int num_args,
     const char** arg_names,
@@ -2045,8 +2053,12 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
   DCHECK(name);
   DCHECK(!timestamp.is_null());
 
-  if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
-    id = MangleEventId(id);
+  if (flags & TRACE_EVENT_FLAG_MANGLE_ID) {
+    if ((flags & TRACE_EVENT_FLAG_FLOW_IN) || (flags & TRACE_EVENT_FLAG_FLOW_OUT))
+      bind_id = MangleEventId(bind_id);
+    else

[dsinclair, 2015/07/20 15:01:32]

Do you want the else here? If we have an id we should always mangle it.

+      id = MangleEventId(id);
+  }
 
   TraceTicks offset_event_timestamp = OffsetTimestamp(timestamp);
   TraceTicks now = flags & TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP ?
@@ -2121,7 +2133,7 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
 
     if (trace_event) {
       trace_event->Initialize(thread_id, offset_event_timestamp, thread_now,
-                              phase, category_group_enabled, name, id,
+                              phase, category_group_enabled, name, id, bind_id,
                               num_args, arg_names, arg_types, arg_values,
                               convertable_values, flags);
 
@@ -2287,7 +2299,7 @@ void TraceLog::UpdateTraceEventDuration(
         subtle::NoBarrier_Load(&event_callback_));
     if (event_callback) {
       event_callback(now, TRACE_EVENT_PHASE_END, category_group_enabled, name,
-                     trace_event_internal::kNoEventId, 0, NULL, NULL, NULL,
+                     trace_event_internal::kNoId, 0, NULL, NULL, NULL,
                      TRACE_EVENT_FLAG_NONE);
     }
   }
@@ -2512,8 +2524,9 @@ ScopedTraceBinaryEfficient::ScopedTraceBinaryEfficient(
     event_handle_ =
         TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
             TRACE_EVENT_PHASE_COMPLETE, category_group_enabled_, name,
-            trace_event_internal::kNoEventId,
+            trace_event_internal::kNoId,
             static_cast<int>(base::PlatformThread::CurrentId()),
+            trace_event_internal::kNoId,
             base::TraceTicks::Now(), 0, NULL, NULL, NULL, NULL,
             TRACE_EVENT_FLAG_NONE);
   }