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

base/trace_event/trace_event_impl.cc

 // 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.
 
 #include "base/trace_event/trace_event_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base_switches.h"
@@ skipping 584 matching lines @@
     unsigned char flags) {
   timestamp_ = timestamp;
   thread_timestamp_ = thread_timestamp;
   duration_ = TimeDelta::FromInternalValue(-1);
   id_ = id;
   category_group_enabled_ = category_group_enabled;
   name_ = name;
   thread_id_ = thread_id;
   phase_ = phase;
   flags_ = flags;
+  flowEvent_ = NULL;
 
   // Clamp num_args since it may have been set by a third_party library.
   num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
   int i = 0;
   for (; i < num_args; ++i) {
     arg_names_[i] = arg_names[i];
     arg_types_[i] = arg_types[i];
 
     if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE)
       convertable_values_[i] = convertable_values[i];
@@ skipping 240 matching lines @@
         scope = TRACE_EVENT_SCOPE_NAME_PROCESS;
         break;
 
       case TRACE_EVENT_SCOPE_THREAD:
         scope = TRACE_EVENT_SCOPE_NAME_THREAD;
         break;
     }
     StringAppendF(out, ",\"s\":\"%c\"", scope);
   }
 
+  // Output flow event info if there is any
+  if (flowEvent_) {
+    StringAppendF(out, ",\"flow\":");
+    flowEvent_->AppendAsJSON(out, argument_filter_predicate);
+  }
+
   *out += "}";
 }
 
 void TraceEvent::AppendPrettyPrinted(std::ostringstream* out) const {
   *out << name_ << "[";
   *out << TraceLog::GetCategoryGroupName(category_group_enabled_);
   *out << "]";
   if (arg_names_[0]) {
     *out << ", {";
     for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
       if (i > 0)
         *out << ", ";
       *out << arg_names_[i] << ":";
       std::string value_as_text;
 
       if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
         convertable_values_[i]->AppendAsTraceFormat(&value_as_text);
       else
         AppendValueAsJSON(arg_types_[i], arg_values_[i], &value_as_text);
 
       *out << value_as_text;
     }
     *out << "}";
   }
 }
 
+bool TraceEvent::isFlowEvent() const {
+  return ((phase() == TRACE_EVENT_PHASE_FLOW_BEGIN) ||
+          (phase() == TRACE_EVENT_PHASE_FLOW_STEP) ||
+          (phase() == TRACE_EVENT_PHASE_FLOW_END));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceResultBuffer
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TraceResultBuffer::OutputCallback
     TraceResultBuffer::SimpleOutput::GetCallback() {
   return Bind(&SimpleOutput::Append, Unretained(this));
 }
@@ skipping 943 matching lines @@
     const OutputCallback& flush_output_callback,
     const TraceEvent::ArgumentFilterPredicate& argument_filter_predicate) {
   if (flush_output_callback.is_null())
     return;
 
   // The callback need to be called at least once even if there is no events
   // to let the caller know the completion of flush.
   scoped_refptr<RefCountedString> json_events_str_ptr = new RefCountedString();
   while (const TraceBufferChunk* chunk = logged_events->NextChunk()) {
     for (size_t j = 0; j < chunk->size(); ++j) {
+      // Flow Events are always bundled to regular events, and will be handled
+      // within their bundled events.
+      if (chunk->GetEventAt(j)->isFlowEvent())
+        continue;
+
       size_t size = json_events_str_ptr->size();
       if (size > kTraceEventBufferSizeInBytes) {
         flush_output_callback.Run(json_events_str_ptr, true);
         json_events_str_ptr = new RefCountedString();
       } else if (size) {
         json_events_str_ptr->data().append(",\n");
       }
       chunk->GetEventAt(j)->AppendAsJSON(&(json_events_str_ptr->data()),
                                          argument_filter_predicate);
     }
@@ skipping 648 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
                                                 name_, event_handle_);
   }
 }
 
 }  // namespace trace_event_internal