More timeline cleanups

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"
@@ skipping 33 matching lines @@
       TimelineStream* stream = NULL) {
     TimelineEvent* event = block->StartEvent();
     ASSERT(event != NULL);
     event->DurationBegin(label);
     event->thread_ = OSThread::ThreadIdFromIntPtr(ftid);
     if (stream != NULL) {
       event->StreamInit(stream);
     }
   }
 
+  static void SetBlockThread(TimelineEventBlock* block,
+                             intptr_t ftid) {
+    block->thread_id_ = OSThread::ThreadIdFromIntPtr(ftid);
+  }
+
   static void FakeDuration(
       TimelineEventRecorder* recorder,
       const char* label,
       int64_t start,
       int64_t end) {
     ASSERT(recorder != NULL);
     ASSERT(start < end);
     ASSERT(label != NULL);
     TimelineEvent* event = recorder->StartEvent();
     ASSERT(event != NULL);
@@ skipping 171 matching lines @@
   EventCounterRecorder() {
     for (intptr_t i = 0; i < TimelineEvent::kNumEventTypes; i++) {
       counts_[i] = 0;
     }
   }
 
   void StreamEvent(TimelineEvent* event) {
     counts_[event->event_type()]++;
   }
 
-  void StreamDartEvent(const char* event) {
-    // NOOP.
-  }
-
   intptr_t CountFor(TimelineEvent::EventType type) {
     return counts_[type];
   }
 
  private:
   intptr_t counts_[TimelineEvent::kNumEventTypes];
 };
 
 
 TEST_CASE(TimelineEventStreamingRecorderBasic) {
@@ skipping 58 matching lines @@
   ASSERT(event != NULL);
   return strcmp(event->label(), label) == 0;
 }
 
 
 TEST_CASE(TimelineAnalysis_ThreadBlockCount) {
   TimelineEventEndlessRecorder* recorder = new TimelineEventEndlessRecorder();
   ASSERT(recorder != NULL);
   // Blocks owned by thread "1".
   TimelineEventBlock* block_1_0 = recorder->GetNewBlock();
+  TimelineTestHelper::SetBlockThread(block_1_0, 1);
   TimelineEventBlock* block_1_1 = recorder->GetNewBlock();
+  TimelineTestHelper::SetBlockThread(block_1_1, 1);
   TimelineEventBlock* block_1_2 = recorder->GetNewBlock();
+  TimelineTestHelper::SetBlockThread(block_1_2, 1);
   // Blocks owned by thread "2".
   TimelineEventBlock* block_2_0 = recorder->GetNewBlock();
+  TimelineTestHelper::SetBlockThread(block_2_0, 2);
   // Blocks owned by thread "3".
   TimelineEventBlock* block_3_0 = recorder->GetNewBlock();
+  TimelineTestHelper::SetBlockThread(block_3_0, 3);
   USE(block_3_0);
 
   // Add events to each block for thread 1.
   TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B1");
   TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B2");
   TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B3");
   // Sleep to ensure timestamps differ.
   OS::Sleep(1);
   TimelineTestHelper::FakeThreadEvent(block_1_0, 1, "A1");
   OS::Sleep(1);
   TimelineTestHelper::FakeThreadEvent(block_1_1, 1, "C1");
   TimelineTestHelper::FakeThreadEvent(block_1_1, 1, "C2");
   OS::Sleep(1);
 
   // Add events to each block for thread 2.
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "A");
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "B");
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "C");
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "D");
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "E");
   TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "F");
 
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
 
   // Discover threads in recorder.
   TimelineAnalysis ta(zone, isolate, recorder);
   ta.BuildThreads();
+  EXPECT(!ta.has_error());
   // block_3_0 is never used by a thread, so we only have two threads.
   EXPECT_EQ(2, ta.NumThreads());
 
   // Extract both threads.
   TimelineAnalysisThread* thread_1 =
       ta.GetThread(OSThread::ThreadIdFromIntPtr(1));
   TimelineAnalysisThread* thread_2 =
       ta.GetThread(OSThread::ThreadIdFromIntPtr(2));
   EXPECT_EQ(OSThread::ThreadIdFromIntPtr(1), thread_1->id());
   EXPECT_EQ(OSThread::ThreadIdFromIntPtr(2), thread_2->id());
@@ skipping 466 matching lines @@
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(pauses.has_error());
   }
   TimelineTestHelper::Clear(recorder);
 }
 
 }  // namespace dart