[Fuchsia] Routes timeline events to Fuchsia's tracing app

runtime/vm/timeline.h

 // 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.
 
 #ifndef RUNTIME_VM_TIMELINE_H_
 #define RUNTIME_VM_TIMELINE_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/allocation.h"
@@ skipping 300 matching lines @@
 
   const char* GetSerializedJSON() const;
 
   void set_owns_label(bool owns_label) {
     state_ = OwnsLabelBit::update(owns_label, state_);
   }
 
   // Returns the number of bytes written into |buffer|.
   intptr_t PrintSystrace(char* buffer, intptr_t buffer_size);
 
+#if defined(HOST_OS_FUCHSIA)
+  void EmitFuchsiaEvent();
+#endif
+
  private:
   void FreeArguments();
 
   void StreamInit(TimelineStream* stream);
   void Init(EventType event_type, const char* label);
 
   void set_event_type(EventType event_type) {
     // We only reserve 4 bits to hold the event type.
     COMPILE_ASSERT(kNumEventTypes < 16);
     state_ = EventTypeField::update(event_type, state_);
@@ skipping 48 matching lines @@
   const char* label_;
   const char* category_;
   ThreadId thread_;
   Dart_Port isolate_id_;
 
   friend class TimelineEventRecorder;
   friend class TimelineEventEndlessRecorder;
   friend class TimelineEventRingRecorder;
   friend class TimelineEventStartupRecorder;
   friend class TimelineEventSystraceRecorder;
+  friend class TimelineEventFuchsiaRecorder;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   DISALLOW_COPY_AND_ASSIGN(TimelineEvent);
 };
 
 
 #ifndef PRODUCT
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, name, function)         \
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(), name);      \
   if (tds.enabled()) {                                                         \
@@ skipping 27 matching lines @@
   TimelineEventScope(TimelineStream* stream, const char* label);
 
   TimelineEventScope(Thread* thread, TimelineStream* stream, const char* label);
 
   bool ShouldEmitEvent() const { return enabled_; }
 
   void set_enabled(bool enabled) { enabled_ = enabled; }
 
   const char* label() const { return label_; }
 
+  TimelineEventArgument* arguments() const { return arguments_; }
+
+  intptr_t arguments_length() const { return arguments_length_; }
+
   TimelineStream* stream() const { return stream_; }
 
   virtual ~TimelineEventScope();
 
   void StealArguments(TimelineEvent* event);
 
  private:
   void Init();
   void FreeArguments();
 
@@ skipping 107 matching lines @@
 
   void Open();
   void Finish();
 
   friend class Thread;
   friend class TimelineEventRecorder;
   friend class TimelineEventEndlessRecorder;
   friend class TimelineEventRingRecorder;
   friend class TimelineEventStartupRecorder;
   friend class TimelineEventSystraceRecorder;
+  friend class TimelineEventFuchsiaRecorder;
   friend class TimelineTestHelper;
   friend class JSONStream;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventBlock);
 };
 
 
 class TimelineEventFilter : public ValueObject {
  public:
@@ skipping 155 matching lines @@
   const char* name() const { return "Systrace"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
   void CompleteEvent(TimelineEvent* event);
 
   int systrace_fd_;
 };
 
 
+#if defined(HOST_OS_FUCHSIA)
+// A recorder that sends events to Fuchsia's tracing app. Events are also stored
+// in a buffer of fixed capacity. When the buffer is full, new events overwrite
+// old events.
+// See: https://fuchsia.googlesource.com/tracing/+/HEAD/docs/usage_guide.md
+class TimelineEventFuchsiaRecorder : public TimelineEventFixedBufferRecorder {
+ public:
+  explicit TimelineEventFuchsiaRecorder(intptr_t capacity = kDefaultCapacity);
+  virtual ~TimelineEventFuchsiaRecorder() {}
+
+  const char* name() const { return "Fuchsia"; }
+
+ protected:
+  TimelineEventBlock* GetNewBlockLocked();
+  void CompleteEvent(TimelineEvent* event);
+};
+#endif  // defined(HOST_OS_FUCHSIA)
+
+
 // A recorder that stores events in a buffer of fixed capacity. When the buffer
 // is full, new events are dropped.
 class TimelineEventStartupRecorder : public TimelineEventFixedBufferRecorder {
  public:
   explicit TimelineEventStartupRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
   virtual ~TimelineEventStartupRecorder() {}
 
   const char* name() const { return "Startup"; }
 
@@ skipping 72 matching lines @@
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_H_