[vm] Support flow events in Dart_TimelineEvent.

runtime/vm/timeline.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #ifndef PRODUCT
 
 #include <errno.h>
 #include <fcntl.h>
 #include <cstdlib>
@@ skipping 441 matching lines @@
   set_thread_timestamp0(thread_micros);
 }
 
 
 void TimelineEvent::Counter(const char* label, int64_t micros) {
   Init(kCounter, label);
   set_timestamp0(micros);
 }
 
 
+void TimelineEvent::FlowBegin(const char* label,
+                              int64_t async_id,
+                              int64_t micros) {
+  Init(kFlowBegin, label);
+  set_timestamp0(micros);
+  // Overload timestamp1_ with the async_id.
+  set_timestamp1(async_id);
+}
+
+
+void TimelineEvent::FlowStep(const char* label,
+                             int64_t async_id,
+                             int64_t micros) {
+  Init(kFlowStep, label);
+  set_timestamp0(micros);
+  // Overload timestamp1_ with the async_id.
+  set_timestamp1(async_id);
+}
+
+
+void TimelineEvent::FlowEnd(const char* label,
+                            int64_t async_id,
+                            int64_t micros) {
+  Init(kFlowEnd, label);
+  set_timestamp0(micros);
+  // Overload timestamp1_ with the async_id.
+  set_timestamp1(async_id);
+}
+
+
 void TimelineEvent::Metadata(const char* label, int64_t micros) {
   Init(kMetadata, label);
   set_timestamp0(micros);
 }
 
 
 void TimelineEvent::CompleteWithPreSerializedJSON(const char* json) {
   set_pre_serialized_json(true);
   SetNumArguments(1);
   CopyArgument(0, "Dart", json);
@@ skipping 83 matching lines @@
     }                                                                          \
   }
 
 FUCHSIA_EVENT_ARGS_LIST(EMIT_FUCHSIA_EVENT)
 #undef EMIT_FUCHSIA_EVENT
 
 #define FUCHSIA_EVENT_ID_ARGS_LIST(V)                                          \
   V(Instant, TRACE_INSTANT, ::tracing::EventScope)                             \
   V(AsyncBegin, TRACE_ASYNC_BEGIN, int64_t)                                    \
   V(AsyncEnd, TRACE_ASYNC_END, int64_t)                                        \
-  V(AsyncInstant, TRACE_ASYNC_INSTANT, int64_t)
+  V(AsyncInstant, TRACE_ASYNC_INSTANT, int64_t)                                \
+  V(FlowBegin, TRACE_FLOW_BEGIN, int64_t)                                      \
+  V(FlowStep, TRACE_FLOW_STEP, int64_t)                                        \
+  V(FlowEnd, TRACE_FLOW_END, int64_t)
 
 #define EMIT_FUCHSIA_EVENT(__name, __macro, __id_typ)                          \
   static void EmitFuchsia##__name##Event(const char* label, __id_typ id,       \
                                          TimelineEventArgument* arguments,     \
                                          intptr_t arguments_length) {          \
     if (arguments_length == 0) {                                               \
       __macro("dart", label, id);                                              \
     } else if (arguments_length == 1) {                                        \
       __macro("dart", label, id, arguments[0].name,                            \
               const_cast<const char*>(arguments[0].value));                    \
@@ skipping 25 matching lines @@
                                  arguments_length_);
       break;
     case kAsyncEnd:
       EmitFuchsiaAsyncEndEvent(label_, AsyncId(), arguments_,
                                arguments_length_);
       break;
     case kAsyncInstant:
       EmitFuchsiaAsyncInstantEvent(label_, AsyncId(), arguments_,
                                    arguments_length_);
       break;
+    case kFlowBegin:
+      EmitFuchsiaFlowBeginEvent(label_, AsyncId(), arguments_,
+                                arguments_length_);
+      break;
+    case kFlowStep:
+      EmitFuchsiaFlowStepEvent(label_, AsyncId(), arguments_,
+                               arguments_length_);
+      break;
+    case kFlowEnd:
+      EmitFuchsiaFlowEndEvent(label_, AsyncId(), arguments_, arguments_length_);
+      break;
     default:
       // TODO(zra): Figure out what to do with kDuration, kCounter, and
       // kMetadata.
       break;
   }
 }
 #endif
 
 
 intptr_t TimelineEvent::PrintSystrace(char* buffer, intptr_t buffer_size) {
@@ skipping 152 matching lines @@
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
     } break;
     case kAsyncInstant: {
       obj.AddProperty("ph", "n");
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
     } break;
     case kAsyncEnd: {
       obj.AddProperty("ph", "e");
       obj.AddPropertyF("id", "%" Px64 "", AsyncId());
     } break;
+    case kCounter: {
+      obj.AddProperty("ph", "C");
+    } break;
+    case kFlowBegin: {
+      obj.AddProperty("ph", "s");
+      obj.AddPropertyF("id", "%" Px64 "", AsyncId());
+    } break;
+    case kFlowStep: {
+      obj.AddProperty("ph", "t");
+      obj.AddPropertyF("id", "%" Px64 "", AsyncId());
+    } break;
+    case kFlowEnd: {
+      obj.AddProperty("ph", "f");
+      obj.AddProperty("bp", "e");
+      obj.AddPropertyF("id", "%" Px64 "", AsyncId());
+    } break;
     case kMetadata: {
       obj.AddProperty("ph", "M");
     } break;
-    case kCounter: {
-      obj.AddProperty("ph", "C");
-    } break;
     default:
       UNIMPLEMENTED();
   }
   {
     JSONObject args(&obj, "args");
     for (intptr_t i = 0; i < arguments_length_; i++) {
       const TimelineEventArgument& arg = arguments_[i];
       args.AddProperty(arg.name, arg.value);
     }
     if (isolate_id_ != ILLEGAL_PORT) {
@@ skipping 522 matching lines @@
   // Free the stolen output.
   free(output);
   (*file_close)(file);
 
   return;
 }
 
 
 int64_t TimelineEventRecorder::GetNextAsyncId() {
   // TODO(johnmccutchan): Gracefully handle wrap around.
+  // TODO(rmacnak): Use TRACE_NONCE() on Fuchsia?
   uint32_t next =
       static_cast<uint32_t>(AtomicOperations::FetchAndIncrement(&async_id_));
   return static_cast<int64_t>(next);
 }
 
 
 void TimelineEventRecorder::FinishBlock(TimelineEventBlock* block) {
   if (block == NULL) {
     return;
   }
@@ skipping 574 matching lines @@
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
 }  // namespace dart
 
 #endif  // !PRODUCT