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

base/trace_event/trace_event_impl.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.
 
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 86 matching lines @@
     unsigned long long as_uint;
     long long as_int;
     double as_double;
     const void* as_pointer;
     const char* as_string;
   };
 
   TraceEvent();
   ~TraceEvent();
 
+  void appendFlowEvent(TraceEvent *flowEvent) {
+    flowEvent_ = flowEvent;
+  }
+
   // We don't need to copy TraceEvent except when TraceEventBuffer is cloned.
   // Use explicit copy method to avoid accidentally misuse of copy.
   void CopyFrom(const TraceEvent& other);
 
   void Initialize(
       int thread_id,
       TraceTicks timestamp,
       ThreadTicks thread_timestamp,
       char phase,
       const unsigned char* category_group_enabled,
@@ skipping 25 matching lines @@
                                 std::string* out);
 
   TraceTicks timestamp() const { return timestamp_; }
   ThreadTicks thread_timestamp() const { return thread_timestamp_; }
   char phase() const { return phase_; }
   int thread_id() const { return thread_id_; }
   TimeDelta duration() const { return duration_; }
   TimeDelta thread_duration() const { return thread_duration_; }
   unsigned long long id() const { return id_; }
   unsigned char flags() const { return flags_; }
+  bool isFlowEvent() const;
 
   // Exposed for unittesting:
 
   const base::RefCountedString* parameter_copy_storage() const {
     return parameter_copy_storage_.get();
   }
 
   const unsigned char* category_group_enabled() const {
     return category_group_enabled_;
   }
@@ skipping 16 matching lines @@
   TraceValue arg_values_[kTraceMaxNumArgs];
   const char* arg_names_[kTraceMaxNumArgs];
   scoped_refptr<ConvertableToTraceFormat> convertable_values_[kTraceMaxNumArgs];
   const unsigned char* category_group_enabled_;
   const char* name_;
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
   int thread_id_;
   char phase_;
   unsigned char flags_;
   unsigned char arg_types_[kTraceMaxNumArgs];
+  TraceEvent *flowEvent_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceEvent);
 };
 
 // TraceBufferChunk is the basic unit of TraceBuffer.
 class BASE_EXPORT TraceBufferChunk {
  public:
   explicit TraceBufferChunk(uint32 seq);
   ~TraceBufferChunk();
 
@@ skipping 504 matching lines @@
   // Set when asynchronous Flush is in progress.
   OutputCallback flush_output_callback_;
   scoped_refptr<SingleThreadTaskRunner> flush_task_runner_;
   TraceEvent::ArgumentFilterPredicate argument_filter_predicate_;
   subtle::AtomicWord generation_;
   bool use_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
+class TraceEventHandleWrapper {
+public:
+  TraceEventHandleWrapper() {
+    handle_ = {0, 0, 0};
+    event_ = NULL;
+  }
+  TraceEventHandleWrapper(TraceEventHandle h) {
+    handle_ = h;
+    TraceLog* tracer = base::trace_event::TraceLog::GetInstance();
+    event_ = tracer->GetEventByHandle(h);
+  }
+
+  void appendFlowEvent(TraceEventHandle h) {
+    if (event_) {
+      TraceLog* tracer = base::trace_event::TraceLog::GetInstance();
+      TraceEvent *flowEvent = tracer->GetEventByHandle(h);
+      event_->appendFlowEvent(flowEvent);
+    }
+  }
+
+private:
+  TraceEventHandle handle_;
+  TraceEvent *event_;
+};
+
+
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_