Timeline API fixes for Flutter

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 VM_TIMELINE_H_
 #define VM_TIMELINE_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/allocation.h"
@@ skipping 10 matching lines @@
 class Isolate;
 class RawArray;
 class Thread;
 class TimelineEvent;
 class TimelineEventBlock;
 class TimelineEventRecorder;
 class TimelineStream;
 class Zone;
 
 // (name, enabled by default for isolate).
-#define ISOLATE_TIMELINE_STREAM_LIST(V)                                        \
+#define TIMELINE_STREAM_LIST(V)                                                \
   V(API, false)                                                                \
   V(Compiler, false)                                                           \
   V(Dart, false)                                                               \
   V(Debugger, false)                                                           \
   V(Embedder, false)                                                           \
   V(GC, false)                                                                 \
   V(Isolate, false)                                                            \
+  V(VM, false)
 
 class Timeline : public AllStatic {
  public:
   // Initialize timeline system. Not thread safe.
   static void InitOnce();
 
   // Shutdown timeline system. Not thread safe.
   static void Shutdown();
 
   // Access the global recorder. Not thread safe.
   static TimelineEventRecorder* recorder();
 
-  static void SetupIsolateStreams(Isolate* isolate);
-
-  static TimelineStream* GetVMStream();
-
-  static TimelineStream* GetVMApiStream();
-
   // Reclaim all |TimelineEventBlocks|s that are cached by threads.
   static void ReclaimCachedBlocksFromThreads();
 
   static void Clear();
 
   // Print information about streams to JSON.
   static void PrintFlagsToJSON(JSONStream* json);
 
-#define ISOLATE_TIMELINE_STREAM_FLAGS(name, not_used)                          \
+#define TIMELINE_STREAM_ACCESSOR(name, not_used)                       \
+  static TimelineStream* Get##name##Stream() { return &stream_##name##_; }
+  TIMELINE_STREAM_LIST(TIMELINE_STREAM_ACCESSOR)
+#undef TIMELINE_STREAM_ACCESSOR
+
+#define TIMELINE_STREAM_FLAGS(name, not_used)                                  \
   static const bool* Stream##name##EnabledFlag() {                             \
     return &stream_##name##_enabled_;                                          \
   }                                                                            \
   static void SetStream##name##Enabled(bool enabled) {                         \
     StreamStateChange(#name, stream_##name##_enabled_, enabled);               \
     stream_##name##_enabled_ = enabled;                                        \
   }
-  ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_FLAGS)
-#undef ISOLATE_TIMELINE_STREAM_FLAGS
-  static void SetVMStreamEnabled(bool enabled);
+  TIMELINE_STREAM_LIST(TIMELINE_STREAM_FLAGS)
+#undef TIMELINE_STREAM_FLAGS
 
   static void set_start_recording_cb(
       Dart_EmbedderTimelineStartRecording start_recording_cb) {
     start_recording_cb_ = start_recording_cb;
   }
 
   static Dart_EmbedderTimelineStartRecording get_start_recording_cb() {
     return start_recording_cb_;
   }
 
   static void set_stop_recording_cb(
       Dart_EmbedderTimelineStopRecording stop_recording_cb) {
     stop_recording_cb_ = stop_recording_cb;
   }
 
   static Dart_EmbedderTimelineStopRecording get_stop_recording_cb() {
     return stop_recording_cb_;
   }
 
-  static void set_get_timeline_cb(
-      Dart_EmbedderTimelineGetTimeline get_timeline_cb) {
-    get_timeline_cb_ = get_timeline_cb;
-  }
-
-  static Dart_EmbedderTimelineGetTimeline get_get_timeline_cb() {
-    return get_timeline_cb_;
-  }
-
  private:
   static void StreamStateChange(const char* stream_name, bool prev, bool curr);
   static TimelineEventRecorder* recorder_;
-  static TimelineStream vm_stream_;
-  static TimelineStream vm_api_stream_;
   static MallocGrowableArray<char*>* enabled_streams_;
   static Dart_EmbedderTimelineStartRecording start_recording_cb_;
   static Dart_EmbedderTimelineStopRecording stop_recording_cb_;
-  static Dart_EmbedderTimelineGetTimeline get_timeline_cb_;
 
-#define ISOLATE_TIMELINE_STREAM_DECLARE_FLAG(name, not_used)                   \
-  static bool stream_##name##_enabled_;
-  ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_DECLARE_FLAG)
-#undef ISOLATE_TIMELINE_STREAM_DECLARE_FLAG
+#define TIMELINE_STREAM_DECLARE(name, not_used)                                \
+  static bool stream_##name##_enabled_;                                        \
+  static TimelineStream stream_##name##_;
+  TIMELINE_STREAM_LIST(TIMELINE_STREAM_DECLARE)
+#undef TIMELINE_STREAM_DECLARE
 
   friend class TimelineRecorderOverride;
   friend class ReclaimBlocksIsolateVisitor;
 };
 
 
 struct TimelineEventArgument {
   const char* name;
   char* value;
 };
@@ skipping 87 matching lines @@
     ASSERT(IsFinishedDuration());
     return timestamp1_;
   }
 
   void PrintJSON(JSONStream* stream) const;
 
   ThreadId thread() const {
     return thread_;
   }
 
+  void set_thread(ThreadId tid) {
+    thread_ = tid;
+  }
+
   Dart_Port isolate_id() const {
     return isolate_id_;
   }
 
   const char* label() const {
     return label_;
   }
 
   // Does this duration end before |micros| ?
   bool DurationFinishedBefore(int64_t micros) const {
@@ skipping 144 matching lines @@
 
  private:
   const char* name_;
   bool enabled_;
   const bool* globally_enabled_;
 };
 
 #ifndef PRODUCT
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, suffix, function)       \
   TimelineDurationScope tds(thread,                                            \
-                            thread->isolate()->GetCompilerStream(),            \
+                            Timeline::GetCompilerStream(),                     \
                             "Compile" suffix);                                 \
   if (tds.enabled()) {                                                         \
     tds.SetNumArguments(1);                                                    \
     tds.CopyArgument(                                                          \
         0,                                                                     \
         "function",                                                            \
         function.ToLibNamePrefixedQualifiedCString());                         \
   }
 #else
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, suffix, function)
@@ skipping 271 matching lines @@
   virtual TimelineEvent* StartEvent() = 0;
   virtual void CompleteEvent(TimelineEvent* event) = 0;
   virtual TimelineEventBlock* GetHeadBlockLocked() = 0;
   virtual TimelineEventBlock* GetNewBlockLocked() = 0;
   virtual void Clear() = 0;
 
   // Utility method(s).
   void PrintJSONMeta(JSONArray* array) const;
   TimelineEvent* ThreadBlockStartEvent();
   void ThreadBlockCompleteEvent(TimelineEvent* event);
-  void PrintEmbedderJSONEvents(JSONStream* events);
 
   Mutex lock_;
   uintptr_t async_id_;
 
   friend class TimelineEvent;
   friend class TimelineEventBlockIterator;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   friend class Timeline;
 
@@ skipping 111 matching lines @@
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_