Special-case Timeline.{start,finish}Sync for Fuchsia

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"
 #include "vm/bitfield.h"
+#include "vm/growable_array.h"
 #include "vm/os.h"
+#include "vm/os_thread.h"
 
 namespace dart {
 
 class JSONArray;
 class JSONObject;
 class JSONStream;
 class Object;
 class ObjectPointerVisitor;
 class Isolate;
 class RawArray;
@@ skipping 296 matching lines @@
   }
 
   bool Within(int64_t time_origin_micros, int64_t time_extent_micros);
 
   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);
+  TimelineEventArgument* arguments() const { return arguments_; }
 
-#if defined(HOST_OS_FUCHSIA)
-  void EmitFuchsiaEvent();
-#endif
+  intptr_t arguments_length() const { return arguments_length_; }
 
  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);
@@ skipping 48 matching lines @@
   uword state_;
   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 TimelineEventPlatformRecorder;
   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()) {                                                         \
     tds.SetNumArguments(1);                                                    \
@@ skipping 153 matching lines @@
   bool in_use_;
 
   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 TimelineEventPlatformRecorder;
   friend class TimelineTestHelper;
   friend class JSONStream;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventBlock);
 };
 
 class TimelineEventFilter : public ValueObject {
  public:
   TimelineEventFilter(int64_t time_origin_micros = -1,
@@ skipping 131 matching lines @@
   explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity)
       : TimelineEventFixedBufferRecorder(capacity) {}
   virtual ~TimelineEventRingRecorder() {}
 
   const char* name() const { return "Ring"; }
 
  protected:
   TimelineEventBlock* GetNewBlockLocked();
 };
 
-// A recorder that writes events to Android Systrace. Events are also stored in
-// a buffer of fixed capacity. When the buffer is full, new events overwrite
-// old events.
-class TimelineEventSystraceRecorder : public TimelineEventFixedBufferRecorder {
- public:
-  explicit TimelineEventSystraceRecorder(intptr_t capacity = kDefaultCapacity);
-  virtual ~TimelineEventSystraceRecorder();
-
-  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 65 matching lines @@
   bool HasNext() const;
 
   // Returns the next block and moves forward.
   TimelineEventBlock* Next();
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
+// The TimelineEventPlatformRecorder records timeline events to a platform
+// specific destination. It's implementation is in the timeline_{linux,...}.cc
+// files.
+class TimelineEventPlatformRecorder : public TimelineEventFixedBufferRecorder {
+ public:
+  explicit TimelineEventPlatformRecorder(intptr_t capacity = kDefaultCapacity);
+  virtual ~TimelineEventPlatformRecorder();
+
+  static TimelineEventPlatformRecorder* CreatePlatformRecorder(
+      intptr_t capacity = kDefaultCapacity);
+
+  const char* name() const;
+
+ protected:
+  TimelineEventBlock* GetNewBlockLocked();
+  virtual void CompleteEvent(TimelineEvent* event);
+};
+
+#if defined(HOST_OS_ANDROID) || defined(HOST_OS_LINUX)
+// A recorder that writes events to Android Systrace. Events are also stored in
+// a buffer of fixed capacity. When the buffer is full, new events overwrite
+// old events. This class is exposed in this header file only so that
+// PrintSystrace can be visible to timeline_test.cc.
+class TimelineEventSystraceRecorder : public TimelineEventPlatformRecorder {
+ public:
+  explicit TimelineEventSystraceRecorder(intptr_t capacity = kDefaultCapacity);
+  virtual ~TimelineEventSystraceRecorder();
+
+  static intptr_t PrintSystrace(TimelineEvent* event,
+                                char* buffer,
+                                intptr_t buffer_size);
+
+ private:
+  virtual void CompleteEvent(TimelineEvent* event);
+
+  int systrace_fd_;
+};
+#endif  // defined(HOST_OS_ANDROID) || defined(HOST_OS_LINUX)
+
+// These helper functions have platform specific implementations defined in
+// the timeline_{linux,...}.cc files. They are called from the runtime calls
+// that implement the dart:developer Timeline API.
+class DartTimelineEventHelpers : public AllStatic {
+ public:
+  static void ReportTaskEvent(Thread* thread,
+                              Zone* zone,
+                              TimelineEvent* event,
+                              int64_t start,
+                              int64_t id,
+                              const char* phase,
+                              const char* category,
+                              const char* name,
+                              const char* args);
+
+  static void ReportCompleteEvent(Thread* thread,
+                                  Zone* zone,
+                                  TimelineEvent* event,
+                                  int64_t start,
+                                  int64_t start_cpu,
+                                  const char* category,
+                                  const char* name,
+                                  const char* args);
+
+  static void ReportInstantEvent(Thread* thread,
+                                 Zone* zone,
+                                 TimelineEvent* event,
+                                 int64_t start,
+                                 const char* category,
+                                 const char* name,
+                                 const char* args);
+};
+
+// These are common implementations of the DartTimelineEventHelpers that should
+// be used when there is nothing platform-specific needed.
+class DartCommonTimelineEventHelpers : public AllStatic {
+ public:
+  static void ReportTaskEvent(Thread* thread,
+                              Zone* zone,
+                              TimelineEvent* event,
+                              int64_t start,
+                              int64_t id,
+                              const char* phase,
+                              const char* category,
+                              const char* name,
+                              const char* args);
+
+  static void ReportCompleteEvent(Thread* thread,
+                                  Zone* zone,
+                                  TimelineEvent* event,
+                                  int64_t start,
+                                  int64_t start_cpu,
+                                  const char* category,
+                                  const char* name,
+                                  const char* args);
+
+  static void ReportInstantEvent(Thread* thread,
+                                 Zone* zone,
+                                 TimelineEvent* event,
+                                 int64_t start,
+                                 const char* category,
+                                 const char* name,
+                                 const char* args);
+};
+
 }  // namespace dart
 
 #endif  // RUNTIME_VM_TIMELINE_H_