More timeline cleanups

runtime/vm/timeline.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 <cstdlib>
 
 #include "vm/atomic.h"
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
@@ skipping 139 matching lines @@
 #undef ISOLATE_TIMELINE_STREAM_DEFINE_FLAG
 
 TimelineEvent::TimelineEvent()
     : timestamp0_(0),
       timestamp1_(0),
       arguments_(NULL),
       arguments_length_(0),
       state_(0),
       label_(NULL),
       category_(""),
-      thread_(OSThread::kInvalidThreadId) {
+      thread_(OSThread::kInvalidThreadId),
+      isolate_id_(ILLEGAL_PORT) {
 }
 
 
 TimelineEvent::~TimelineEvent() {
   Reset();
 }
 
 
 void TimelineEvent::Reset() {
   set_event_type(kNone);
   thread_ = OSThread::kInvalidThreadId;
-  isolate_ = NULL;
+  isolate_id_ = ILLEGAL_PORT;
   category_ = "";
   label_ = NULL;
   FreeArguments();
 }
 
 
 void TimelineEvent::AsyncBegin(const char* label, int64_t async_id) {
   Init(kAsyncBegin, label);
   timestamp0_ = OS::GetCurrentTraceMicros();
   // Overload timestamp1_ with the async_id.
@@ skipping 52 matching lines @@
 }
 
 
 void TimelineEvent::End(const char* label,
                         int64_t micros) {
   Init(kEnd, label);
   timestamp0_ = micros;
 }
 
 
+void TimelineEvent::SerializedJSON(const char* json) {
+  Init(kSerializedJSON, "Dart");
+  SetNumArguments(1);
+  CopyArgument(0, "Dart", json);
+}
+
+
 void TimelineEvent::SetNumArguments(intptr_t length) {
   // Cannot call this twice.
   ASSERT(arguments_ == NULL);
   ASSERT(arguments_length_ == 0);
   if (length == 0) {
     return;
   }
   arguments_length_ = length;
   arguments_ = reinterpret_cast<TimelineEventArgument*>(
       calloc(sizeof(TimelineEventArgument), length));
@@ skipping 71 matching lines @@
 }
 
 
 void TimelineEvent::Init(EventType event_type,
                          const char* label) {
   ASSERT(label != NULL);
   set_event_type(event_type);
   timestamp0_ = 0;
   timestamp1_ = 0;
   thread_ = OSThread::GetCurrentThreadTraceId();
-  isolate_ = Isolate::Current();
+  Isolate* isolate = Isolate::Current();
+  if (isolate != NULL) {
+    isolate_id_ = isolate->main_port();
+  } else {
+    isolate_id_ = ILLEGAL_PORT;
+  }
   label_ = label;
   FreeArguments();
 }
 
 
+const char* TimelineEvent::GetSerializedJSON() const {
+  ASSERT(event_type() == kSerializedJSON);
+  ASSERT(arguments_length_ == 1);
+  ASSERT(arguments_ != NULL);
+  return arguments_[0].value;
+}
+
+
 void TimelineEvent::PrintJSON(JSONStream* stream) const {
+  if (event_type() == kSerializedJSON) {
+    // Event has already been serialized into JSON- just append the
+    // raw data.
+    stream->AppendSerializedObject(GetSerializedJSON());
+    return;
+  }
   JSONObject obj(stream);
   int64_t pid = OS::ProcessId();
   int64_t tid = OSThread::ThreadIdToIntPtr(thread_);
   obj.AddProperty("name", label_);
   obj.AddProperty("cat", category_);
   obj.AddProperty64("tid", tid);
   obj.AddProperty64("pid", pid);
   obj.AddPropertyTimeMicros("ts", TimeOrigin());
 
   switch (event_type()) {
@@ skipping 32 matching lines @@
     break;
     default:
       UNIMPLEMENTED();
   }
   {
     JSONObject args(&obj, "args");
     for (intptr_t i = 0; i < arguments_length_; i++) {
       const TimelineEventArgument& arg = arguments_[i];
       args.AddProperty(arg.name, arg.value);
     }
+    if (isolate_id_ != ILLEGAL_PORT) {
+      // If we have one, append the isolate id.
+      args.AddProperty("isolateNumber", isolate_id_);
+    }
   }
 }
 
 
 int64_t TimelineEvent::TimeOrigin() const {
   return timestamp0_;
 }
 
 
 int64_t TimelineEvent::AsyncId() const {
@@ skipping 176 matching lines @@
 
 
 TimelineEventFilter::TimelineEventFilter() {
 }
 
 
 TimelineEventFilter::~TimelineEventFilter() {
 }
 
 
-IsolateTimelineEventFilter::IsolateTimelineEventFilter(Isolate* isolate)
-    : isolate_(isolate) {
+IsolateTimelineEventFilter::IsolateTimelineEventFilter(Dart_Port isolate_id)
+    : isolate_id_(isolate_id) {
 }
 
 
-DartTimelineEvent::DartTimelineEvent()
-    : isolate_(NULL),
-      event_as_json_(NULL) {
-}
-
-
-DartTimelineEvent::~DartTimelineEvent() {
-  Clear();
-}
-
-
-void DartTimelineEvent::Clear() {
-  if (isolate_ != NULL) {
-    isolate_ = NULL;
-  }
-  if (event_as_json_ != NULL) {
-    free(event_as_json_);
-    event_as_json_ = NULL;
-  }
-}
-
-
-void DartTimelineEvent::Init(Isolate* isolate, const char* event) {
-  ASSERT(isolate_ == NULL);
-  ASSERT(event != NULL);
-  isolate_ = isolate;
-  event_as_json_ = strdup(event);
-}
-
-
 TimelineEventRecorder::TimelineEventRecorder()
     : async_id_(0) {
 }
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
 }
 
 
 TimelineEvent* TimelineEventRecorder::ThreadBlockStartEvent() {
   // Grab the current thread.
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
-  ASSERT(thread->isolate() != NULL);
   Mutex* thread_block_lock = thread->timeline_block_lock();
   ASSERT(thread_block_lock != NULL);
   // We are accessing the thread's timeline block- so take the lock here.
   // This lock will be held until the call to |CompleteEvent| is made.
   thread_block_lock->Lock();
 
   TimelineEventBlock* thread_block = thread->timeline_block();
 
   if ((thread_block != NULL) && thread_block->IsFull()) {
     MutexLocker ml(&lock_);
     // Thread has a block and it is full:
     // 1) Mark it as finished.
     thread_block->Finish();
     // 2) Allocate a new block.
-    thread_block = GetNewBlockLocked(thread->isolate());
+    thread_block = GetNewBlockLocked();
     thread->set_timeline_block(thread_block);
   } else if (thread_block == NULL) {
     MutexLocker ml(&lock_);
     // Thread has no block. Attempt to allocate one.
-    thread_block = GetNewBlockLocked(thread->isolate());
+    thread_block = GetNewBlockLocked();
     thread->set_timeline_block(thread_block);
   }
   if (thread_block != NULL) {
     // NOTE: We are exiting this function with the thread's block lock held.
     ASSERT(!thread_block->IsFull());
     TimelineEvent* event = thread_block->StartEvent();
     return event;
   }
   // Drop lock here as no event is being handed out.
   thread_block_lock->Unlock();
   return NULL;
 }
 
 
 void TimelineEventRecorder::ThreadBlockCompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   // Grab the current thread.
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   // Unlock the thread's block lock.
   Mutex* thread_block_lock = thread->timeline_block_lock();
   ASSERT(thread_block_lock != NULL);
   thread_block_lock->Unlock();
 }
 
 
-// Trims the ']' character.
-static void TrimOutput(char* output,
-                       intptr_t* output_length) {
-  ASSERT(output != NULL);
-  ASSERT(output_length != NULL);
-  ASSERT(*output_length >= 2);
-  // We expect the first character to be the opening of an array.
-  ASSERT(output[0] == '[');
-  // We expect the last character to be the closing of an array.
-  ASSERT(output[*output_length - 1] == ']');
-  // Skip the ].
-  *output_length -= 1;
-}
-
-
 void TimelineEventRecorder::WriteTo(const char* directory) {
   Dart_FileOpenCallback file_open = Isolate::file_open_callback();
   Dart_FileWriteCallback file_write = Isolate::file_write_callback();
   Dart_FileCloseCallback file_close = Isolate::file_close_callback();
   if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
     return;
   }
   Thread* T = Thread::Current();
   StackZone zone(T);
 
@@ skipping 10 matching lines @@
   }
   free(filename);
 
   JSONStream js;
   TimelineEventFilter filter;
   PrintTraceEvent(&js, &filter);
   // Steal output from JSONStream.
   char* output = NULL;
   intptr_t output_length = 0;
   js.Steal(const_cast<const char**>(&output), &output_length);
-  TrimOutput(output, &output_length);
-  ASSERT(output_length >= 1);
   (*file_write)(output, output_length, file);
   // Free the stolen output.
   free(output);
-
-  const char* dart_events =
-      DartTimelineEventIterator::PrintTraceEvents(this,
-                                                  zone.GetZone(),
-                                                  NULL);
-
-  // If we wrote out vm events and have dart events, write out the comma.
-  if ((output_length > 1) && (dart_events != NULL)) {
-    // Write out the ',' character.
-    const char* comma = ",";
-    (*file_write)(comma, 1, file);
-  }
-
-  // Write out the Dart events.
-  if (dart_events != NULL) {
-    (*file_write)(dart_events, strlen(dart_events), file);
-  }
-
-  // Write out the ']' character.
-  const char* array_close = "]";
-  (*file_write)(array_close, 1, file);
   (*file_close)(file);
 
   return;
 }
 
 
 int64_t TimelineEventRecorder::GetNextAsyncId() {
   // TODO(johnmccutchan): Gracefully handle wrap around.
   uint32_t next = static_cast<uint32_t>(
       AtomicOperations::FetchAndIncrement(&async_id_));
   return static_cast<int64_t>(next);
 }
 
 
 void TimelineEventRecorder::FinishBlock(TimelineEventBlock* block) {
   if (block == NULL) {
     return;
   }
   MutexLocker ml(&lock_);
   block->Finish();
 }
 
 
 TimelineEventBlock* TimelineEventRecorder::GetNewBlock() {
   MutexLocker ml(&lock_);
-  return GetNewBlockLocked(Isolate::Current());
+  return GetNewBlockLocked();
 }
 
 
 TimelineEventRingRecorder::TimelineEventRingRecorder(intptr_t capacity)
     : blocks_(NULL),
       capacity_(capacity),
       num_blocks_(0),
-      block_cursor_(0),
-      dart_events_(NULL),
-      dart_events_capacity_(capacity),
-      dart_events_cursor_(0) {
+      block_cursor_(0) {
   // Capacity must be a multiple of TimelineEventBlock::kBlockSize
   ASSERT((capacity % TimelineEventBlock::kBlockSize) == 0);
   // Allocate blocks array.
   num_blocks_ = capacity / TimelineEventBlock::kBlockSize;
   blocks_ =
       reinterpret_cast<TimelineEventBlock**>(
           calloc(num_blocks_, sizeof(TimelineEventBlock*)));
   // Allocate each block.
   for (intptr_t i = 0; i < num_blocks_; i++) {
     blocks_[i] = new TimelineEventBlock(i);
   }
   // Chain blocks together.
   for (intptr_t i = 0; i < num_blocks_ - 1; i++) {
     blocks_[i]->set_next(blocks_[i + 1]);
   }
-  // Pre-allocate DartTimelineEvents.
-  dart_events_ =
-      reinterpret_cast<DartTimelineEvent**>(
-          calloc(dart_events_capacity_, sizeof(DartTimelineEvent*)));
-  for (intptr_t i = 0; i < dart_events_capacity_; i++) {
-    dart_events_[i] = new DartTimelineEvent();
-  }
 }
 
 
 TimelineEventRingRecorder::~TimelineEventRingRecorder() {
   // Delete all blocks.
   for (intptr_t i = 0; i < num_blocks_; i++) {
     TimelineEventBlock* block = blocks_[i];
     delete block;
   }
   free(blocks_);
-  // Delete all DartTimelineEvents.
-  for (intptr_t i = 0; i < dart_events_capacity_; i++) {
-    DartTimelineEvent* event = dart_events_[i];
-    delete event;
-  }
-  free(dart_events_);
 }
 
 
 void TimelineEventRingRecorder::PrintJSONEvents(
     JSONArray* events,
     TimelineEventFilter* filter) const {
   intptr_t block_offset = FindOldestBlockIndex();
   if (block_offset == -1) {
     // All blocks are empty.
     return;
@@ skipping 20 matching lines @@
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events, filter);
   }
 }
 
 
-void TimelineEventRingRecorder::AppendDartEvent(Isolate* isolate,
-                                                const char* event) {
-  MutexLocker ml(&lock_);
-  // TODO(johnmccutchan): If locking becomes an issue, use the Isolate to store
-  // the events.
-  if (dart_events_cursor_ == dart_events_capacity_) {
-    dart_events_cursor_ = 0;
-  }
-  ASSERT(dart_events_[dart_events_cursor_] != NULL);
-  dart_events_[dart_events_cursor_]->Clear();
-  dart_events_[dart_events_cursor_]->Init(isolate, event);
-  dart_events_cursor_++;
-}
-
-
-intptr_t TimelineEventRingRecorder::NumDartEventsLocked() {
-  return dart_events_capacity_;
-}
-
-
-DartTimelineEvent* TimelineEventRingRecorder::DartEventAtLocked(intptr_t i) {
-  ASSERT(i >= 0);
-  ASSERT(i < dart_events_capacity_);
-  return dart_events_[i];
-}
-
-
 void TimelineEventRingRecorder::PrintTraceEvent(JSONStream* js,
                                                 TimelineEventFilter* filter) {
   JSONArray events(js);
   PrintJSONEvents(&events, filter);
 }
 
 
 TimelineEventBlock* TimelineEventRingRecorder::GetHeadBlockLocked() {
   return blocks_[0];
 }
 
 
-TimelineEventBlock* TimelineEventRingRecorder::GetNewBlockLocked(
-    Isolate* isolate) {
+TimelineEventBlock* TimelineEventRingRecorder::GetNewBlockLocked() {
   // TODO(johnmccutchan): This function should only hand out blocks
   // which have been marked as finished.
   if (block_cursor_ == num_blocks_) {
     block_cursor_ = 0;
   }
   TimelineEventBlock* block = blocks_[block_cursor_++];
   block->Reset();
-  block->Open(isolate);
+  block->Open();
   return block;
 }
 
 
 intptr_t TimelineEventRingRecorder::FindOldestBlockIndex() const {
   int64_t earliest_time = kMaxInt64;
   intptr_t earliest_index = -1;
   for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
     TimelineEventBlock* block = blocks_[block_idx];
     if (block->IsEmpty()) {
@@ skipping 44 matching lines @@
 }
 
 
 void TimelineEventStreamingRecorder::PrintTraceEvent(
     JSONStream* js,
     TimelineEventFilter* filter) {
   JSONArray events(js);
 }
 
 
-void TimelineEventStreamingRecorder::AppendDartEvent(Isolate* isolate,
-                                                     const char* event) {
-  if (event != NULL) {
-    StreamDartEvent(event);
-  }
-}
-
-
-intptr_t TimelineEventStreamingRecorder::NumDartEventsLocked() {
-  return 0;
-}
-
-
-DartTimelineEvent* TimelineEventStreamingRecorder::DartEventAtLocked(
-    intptr_t i) {
-  return NULL;
-}
-
-
 TimelineEvent* TimelineEventStreamingRecorder::StartEvent() {
   TimelineEvent* event = new TimelineEvent();
   return event;
 }
 
 
 void TimelineEventStreamingRecorder::CompleteEvent(TimelineEvent* event) {
   StreamEvent(event);
   delete event;
 }
 
 
 TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
     : head_(NULL),
-      block_index_(0),
-      dart_events_(NULL),
-      dart_events_capacity_(0),
-      dart_events_cursor_(0) {
+      block_index_(0) {
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js,
                                              TimelineEventFilter* filter) {
   MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events, filter);
   }
 }
 
 
 void TimelineEventEndlessRecorder::PrintTraceEvent(
     JSONStream* js,
     TimelineEventFilter* filter) {
   JSONArray events(js);
   PrintJSONEvents(&events, filter);
 }
 
 
-void TimelineEventEndlessRecorder::AppendDartEvent(Isolate* isolate,
-                                                   const char* event) {
-  MutexLocker ml(&lock_);
-  // TODO(johnmccutchan): If locking becomes an issue, use the Isolate to store
-  // the events.
-  if (dart_events_cursor_ == dart_events_capacity_) {
-    // Grow.
-    intptr_t new_capacity =
-        (dart_events_capacity_ == 0) ? 16 : dart_events_capacity_ * 2;
-    dart_events_ = reinterpret_cast<DartTimelineEvent**>(
-        realloc(dart_events_, new_capacity * sizeof(DartTimelineEvent*)));
-    for (intptr_t i = dart_events_capacity_; i < new_capacity; i++) {
-      // Fill with NULLs.
-      dart_events_[i] = NULL;
-    }
-    dart_events_capacity_ = new_capacity;
-  }
-  ASSERT(dart_events_cursor_ < dart_events_capacity_);
-  DartTimelineEvent* dart_event = new DartTimelineEvent();
-  dart_event->Init(isolate, event);
-  ASSERT(dart_events_[dart_events_cursor_] == NULL);
-  dart_events_[dart_events_cursor_++] = dart_event;
-}
-
-
 TimelineEventBlock* TimelineEventEndlessRecorder::GetHeadBlockLocked() {
   return head_;
 }
 
 
 TimelineEvent* TimelineEventEndlessRecorder::StartEvent() {
   // Grab the current thread.
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   return ThreadBlockStartEvent();
 }
 
 
 void TimelineEventEndlessRecorder::CompleteEvent(TimelineEvent* event) {
   if (event == NULL) {
     return;
   }
   ThreadBlockCompleteEvent(event);
 }
 
 
-TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlockLocked(
-    Isolate* isolate) {
+TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlockLocked() {
   TimelineEventBlock* block = new TimelineEventBlock(block_index_++);
   block->set_next(head_);
-  block->Open(isolate);
+  block->Open();
   head_ = block;
   if (FLAG_trace_timeline) {
-    if (isolate != NULL) {
-      OS::Print("Created new isolate block %p for %s\n",
-                block, isolate->name());
-    } else {
-      OS::Print("Created new global block %p\n", block);
-    }
+    OS::Print("Created new block %p\n", block);
   }
   return head_;
 }
 
 
-intptr_t TimelineEventEndlessRecorder::NumDartEventsLocked() {
-  return dart_events_cursor_;
-}
-
-
-DartTimelineEvent* TimelineEventEndlessRecorder::DartEventAtLocked(
-    intptr_t i) {
-  ASSERT(i >= 0);
-  ASSERT(i < dart_events_cursor_);
-  return dart_events_[i];
-}
-
-
 void TimelineEventEndlessRecorder::PrintJSONEvents(
     JSONArray* events,
     TimelineEventFilter* filter) const {
   TimelineEventBlock* current = head_;
 
   while (current != NULL) {
     if (!filter->IncludeBlock(current)) {
       current = current->next();
       continue;
     }
@@ skipping 21 matching lines @@
   block_index_ = 0;
   Thread* thread = Thread::Current();
   thread->set_timeline_block(NULL);
 }
 
 
 TimelineEventBlock::TimelineEventBlock(intptr_t block_index)
     : next_(NULL),
       length_(0),
       block_index_(block_index),
-      isolate_(NULL),
+      thread_id_(OSThread::kInvalidThreadId),
       in_use_(false) {
 }
 
 
 TimelineEventBlock::~TimelineEventBlock() {
   Reset();
 }
 
 
 TimelineEvent* TimelineEventBlock::StartEvent() {
   ASSERT(!IsFull());
   if (FLAG_trace_timeline) {
     OS::Print("StartEvent in block %p for thread %" Px "\n",
               this, OSThread::CurrentCurrentThreadIdAsIntPtr());
   }
   return &events_[length_++];
 }
 
 
-ThreadId TimelineEventBlock::thread() const {
-  ASSERT(length_ > 0);
-  return events_[0].thread();
-}
-
-
 int64_t TimelineEventBlock::LowerTimeBound() const {
+  if (length_ == 0) {
+    return kMaxInt64;
+  }
   ASSERT(length_ > 0);
   return events_[0].TimeOrigin();
 }
 
 
 bool TimelineEventBlock::CheckBlock() {
   if (length() == 0) {
     return true;
   }
 
-  // - events in the block come from one thread.
-  ThreadId tid = thread();
   for (intptr_t i = 0; i < length(); i++) {
-    if (At(i)->thread() != tid) {
+    if (At(i)->thread() != thread_id()) {
       return false;
     }
   }
 
   // - events have monotonically increasing timestamps.
   int64_t last_time = LowerTimeBound();
   for (intptr_t i = 0; i < length(); i++) {
     if (last_time > At(i)->TimeOrigin()) {
       return false;
     }
     last_time = At(i)->TimeOrigin();
   }
 
   return true;
 }
 
 
 void TimelineEventBlock::Reset() {
   for (intptr_t i = 0; i < kBlockSize; i++) {
     // Clear any extra data.
     events_[i].Reset();
   }
   length_ = 0;
-  isolate_ = NULL;
+  thread_id_ = OSThread::kInvalidThreadId;
   in_use_ = false;
 }
 
 
-void TimelineEventBlock::Open(Isolate* isolate) {
-  isolate_ = isolate;
+void TimelineEventBlock::Open() {
+  thread_id_ = OSThread::GetCurrentThreadTraceId();
   in_use_ = true;
 }
 
 
 void TimelineEventBlock::Finish() {
   if (FLAG_trace_timeline) {
     OS::Print("Finish block %p\n", this);
   }
   in_use_ = false;
 }
@@ skipping 35 matching lines @@
 }
 
 
 TimelineEventBlock* TimelineEventBlockIterator::Next() {
   ASSERT(current_ != NULL);
   TimelineEventBlock* r = current_;
   current_ = current_->next();
   return r;
 }
 
-
-DartTimelineEventIterator::DartTimelineEventIterator(
-    TimelineEventRecorder* recorder)
-    : cursor_(0),
-      num_events_(0),
-      recorder_(NULL) {
-  Reset(recorder);
-}
-
-
-DartTimelineEventIterator::~DartTimelineEventIterator() {
-  Reset(NULL);
-}
-
-
-void DartTimelineEventIterator::Reset(TimelineEventRecorder* recorder) {
-  // Clear state.
-  cursor_ = 0;
-  num_events_ = 0;
-  if (recorder_ != NULL) {
-    // Unlock old recorder.
-    recorder_->lock_.Unlock();
-  }
-  recorder_ = recorder;
-  if (recorder_ == NULL) {
-    return;
-  }
-  // Lock new recorder.
-  recorder_->lock_.Lock();
-  cursor_ = 0;
-  num_events_ = recorder_->NumDartEventsLocked();
-}
-
-
-bool DartTimelineEventIterator::HasNext() const {
-  return cursor_ < num_events_;
-}
-
-
-DartTimelineEvent* DartTimelineEventIterator::Next() {
-  ASSERT(cursor_ < num_events_);
-  DartTimelineEvent* r = recorder_->DartEventAtLocked(cursor_);
-  cursor_++;
-  return r;
-}
-
-const char* DartTimelineEventIterator::PrintTraceEvents(
-    TimelineEventRecorder* recorder,
-    Zone* zone,
-    Isolate* isolate) {
-  if (recorder == NULL) {
-    return NULL;
-  }
-
-  if (zone == NULL) {
-    return NULL;
-  }
-
-  char* result = NULL;
-  DartTimelineEventIterator iterator(recorder);
-  while (iterator.HasNext()) {
-    DartTimelineEvent* event = iterator.Next();
-    if (!event->IsValid()) {
-      // Skip invalid
-      continue;
-    }
-    if ((isolate != NULL) && (isolate != event->isolate())) {
-      // If an isolate was specified, skip events from other isolates.
-      continue;
-    }
-    ASSERT(event->event_as_json() != NULL);
-    result = zone->ConcatStrings(result, event->event_as_json());
-  }
-  return result;
-}
-
 }  // namespace dart