Cleanup timeline stream enabled flag so that it can be easily tested from an intrinsic

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 20 matching lines @@
 #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)
 
+// A stream of timeline events. A stream has a name and can be enabled or
+// disabled (globally and per isolate).
+class TimelineStream {
+ public:
+  TimelineStream();
+
+  void Init(const char* name,
+            bool enabled);
+
+  const char* name() const {
+    return name_;
+  }
+
+  bool enabled() const {
+    return enabled_ != 0;
+  }
+
+  void set_enabled(bool enabled) {
+    enabled_ = enabled ? 1 : 0;
+  }
+
+  // Records an event. Will return |NULL| if not enabled. The returned
+  // |TimelineEvent| is in an undefined state and must be initialized.
+  // NOTE: It is not allowed to call StartEvent again without completing
+  // the first event.
+  TimelineEvent* StartEvent();
+
+  static intptr_t enabled_offset() {
+    return OFFSET_OF(TimelineStream, enabled_);
+  }
+
+ private:
+  const char* name_;
+  uintptr_t enabled_;
+};
+
 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();
 
   // 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 TIMELINE_STREAM_ACCESSOR(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;                                        \
+    StreamStateChange(#name, stream_##name##_.enabled(), enabled);             \
+    stream_##name##_.set_enabled(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() {
@@ skipping 294 matching lines @@
   friend class TimelineEventRecorder;
   friend class TimelineEventEndlessRecorder;
   friend class TimelineEventRingRecorder;
   friend class TimelineEventStartupRecorder;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   DISALLOW_COPY_AND_ASSIGN(TimelineEvent);
 };
 
 
-// A stream of timeline events. A stream has a name and can be enabled or
-// disabled (globally and per isolate).
-class TimelineStream {
- public:
-  TimelineStream();
-
-  void Init(const char* name,
-            bool enabled,
-            const bool* globally_enabled = NULL);
-
-  const char* name() const {
-    return name_;
-  }
-
-  bool Enabled() const {
-    return ((globally_enabled_ != NULL) && *globally_enabled_) ||
-           enabled();
-  }
-
-  bool enabled() const {
-    return enabled_;
-  }
-
-  void set_enabled(bool enabled) {
-    enabled_ = enabled;
-  }
-
-  // Records an event. Will return |NULL| if not enabled. The returned
-  // |TimelineEvent| is in an undefined state and must be initialized.
-  // NOTE: It is not allowed to call StartEvent again without completing
-  // the first event.
-  TimelineEvent* StartEvent();
-
- private:
-  const char* name_;
-  bool enabled_;
-  const bool* globally_enabled_;
-};
-
 #ifndef PRODUCT
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, name, function)         \
   TimelineDurationScope tds(thread,                                            \
                             Timeline::GetCompilerStream(),                     \
                             name);                                             \
   if (tds.enabled()) {                                                         \
     tds.SetNumArguments(1);                                                    \
     tds.CopyArgument(                                                          \
         0,                                                                     \
         "function",                                                            \
@@ skipping 449 matching lines @@
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_