Switch to a VM wide timeline recorder

runtime/vm/timeline_test.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 <cstring>
 
 #include "platform/assert.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/globals.h"
 #include "vm/timeline.h"
 #include "vm/timeline_analysis.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
+class TimelineRecorderOverride : public ValueObject {
+ public:
+  explicit TimelineRecorderOverride(TimelineEventRecorder* new_recorder)
+      : recorder_(Timeline::recorder()) {
+    Timeline::recorder_ = new_recorder;
+  }
+
+  ~TimelineRecorderOverride() {
+    Timeline::recorder_ = recorder_;
+  }
+
+ private:
+  TimelineEventRecorder* recorder_;
+};
+
+
 class TimelineTestHelper : public AllStatic {
  public:
   static void SetStream(TimelineEvent* event, TimelineStream* stream) {
     event->StreamInit(stream);
   }
 
   static TimelineEvent* FakeThreadEvent(
       TimelineEventBlock* block,
       intptr_t ftid,
       const char* label = "fake",
@@ skipping 18 matching lines @@
     ASSERT(label != NULL);
     TimelineEvent* event = recorder->StartEvent();
     ASSERT(event != NULL);
     event->Duration(label, start, end);
   }
 
   static void Clear(TimelineEventEndlessRecorder* recorder) {
     ASSERT(recorder != NULL);
     recorder->Clear();
   }
+
+  static void FinishBlock(TimelineEventBlock* block) {
+    block->Finish();
+  }
 };
 
 
 TEST_CASE(TimelineEventIsValid) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
@@ skipping 99 matching lines @@
     event.PrintJSON(&js);
 
     // Check both arguments.
     EXPECT_SUBSTRING("\"arg1\":\"value1\"", js.ToCString());
     EXPECT_SUBSTRING("\"arg2\":\"value2\"", js.ToCString());
   }
 }
 
 
 TEST_CASE(TimelineEventBufferPrintJSON) {
-  Isolate* isolate = Isolate::Current();
-  TimelineEventRecorder* recorder = isolate->timeline_event_recorder();
+  TimelineEventRecorder* recorder = Timeline::recorder();
   JSONStream js;
-  recorder->PrintJSON(&js);
+  TimelineEventFilter filter;
+  recorder->PrintJSON(&js, &filter);
   // Check the type. This test will fail if we ever make Timeline public.
   EXPECT_SUBSTRING("\"type\":\"_Timeline\"", js.ToCString());
   // Check that there is a traceEvents array.
   EXPECT_SUBSTRING("\"traceEvents\":[", js.ToCString());
 }
 
 
 // Count the number of each event type seen.
 class EventCounterRecorder : public TimelineEventStreamingRecorder {
  public:
@@ skipping 11 matching lines @@
     return counts_[type];
   }
 
  private:
   intptr_t counts_[TimelineEvent::kNumEventTypes];
 };
 
 
 TEST_CASE(TimelineEventStreamingRecorderBasic) {
   EventCounterRecorder* recorder = new EventCounterRecorder();
+  TimelineRecorderOverride override(recorder);
 
   // Initial counts are all zero.
   for (intptr_t i = TimelineEvent::kNone + 1;
        i < TimelineEvent::kNumEventTypes;
        i++) {
     EXPECT_EQ(0, recorder->CountFor(static_cast<TimelineEvent::EventType>(i)));
   }
 
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
-  stream.set_recorder(recorder);
 
   TimelineEvent* event = NULL;
 
   event = stream.StartEvent();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kDuration));
   event->DurationBegin("cabbage");
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kDuration));
   event->DurationEnd();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kDuration));
   event->Complete();
   EXPECT_EQ(1, recorder->CountFor(TimelineEvent::kDuration));
 
   event = stream.StartEvent();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kInstant));
   event->Instant("instantCabbage");
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kInstant));
   event->Complete();
   EXPECT_EQ(1, recorder->CountFor(TimelineEvent::kInstant));
 
   event = stream.StartEvent();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncBegin));
-  int64_t async_id = event->AsyncBegin("asyncBeginCabbage");
+  int64_t async_id = recorder->GetNextAsyncId();
   EXPECT(async_id >= 0);
+  event->AsyncBegin("asyncBeginCabbage", async_id);
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncBegin));
   event->Complete();
   EXPECT_EQ(1, recorder->CountFor(TimelineEvent::kAsyncBegin));
 
   event = stream.StartEvent();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncInstant));
   event->AsyncInstant("asyncInstantCabbage", async_id);
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncInstant));
   event->Complete();
   EXPECT_EQ(1, recorder->CountFor(TimelineEvent::kAsyncInstant));
@@ skipping 138 matching lines @@
   EXPECT(block_1 != NULL);
   // Test that we wrapped.
   EXPECT(block_0 == recorder->GetNewBlock());
 
   // Emit the earlier event into block_1.
   TimelineTestHelper::FakeThreadEvent(block_1, 2, "Alpha", &stream);
   OS::Sleep(1);
   // Emit the later event into block_0.
   TimelineTestHelper::FakeThreadEvent(block_0, 2, "Beta", &stream);
 
+  TimelineTestHelper::FinishBlock(block_0);
+  TimelineTestHelper::FinishBlock(block_1);
+
   JSONStream js;
-  recorder->PrintJSON(&js);
+  TimelineEventFilter filter;
+  recorder->PrintJSON(&js, &filter);
   // trace-event has a requirement that events for a thread must have
   // monotonically increasing timestamps.
   // Verify that "Alpha" comes before "Beta" even though "Beta" is in the first
   // block.
   const char* alpha = strstr(js.ToCString(), "Alpha");
   const char* beta = strstr(js.ToCString(), "Beta");
   EXPECT(alpha < beta);
 }
 
 
@@ skipping 161 matching lines @@
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(10, pauses.ExclusiveTime("a"));
     EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
     EXPECT_EQ(8, pauses.MaxExclusiveTime("a"));
   }
   TimelineTestHelper::Clear(recorder);
 }
 
 }  // namespace dart