Refactor Dart_TimelineGetTrace to use a StreamConsumer callback

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 5767 matching lines @@
       (stream_mask & DART_TIMELINE_STREAM_COMPILER) != 0);
   isolate->GetEmbedderStream()->set_enabled(
       (stream_mask & DART_TIMELINE_STREAM_EMBEDDER) != 0);
   isolate->GetGCStream()->set_enabled(
       (stream_mask & DART_TIMELINE_STREAM_GC) != 0);
   isolate->GetIsolateStream()->set_enabled(
       (stream_mask & DART_TIMELINE_STREAM_ISOLATE) != 0);
 }
 
 
-DART_EXPORT bool Dart_TimelineGetTrace(const char** output,
-                                       intptr_t* output_length) {
+DART_EXPORT bool Dart_TimelineGetTrace(Dart_StreamConsumer consumer,
+                                       void* user_data) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  if (output == NULL) {
-    return false;
-  }
-  if (output_length == NULL) {
+  if (consumer == NULL) {
     return false;
   }
   TimelineEventRecorder* timeline_recorder = isolate->timeline_event_recorder();
   if (timeline_recorder == NULL) {
     // Nothing has been recorded.
     return false;
   }
   // Suspend execution of other threads while serializing to JSON.
   isolate->thread_registry()->SafepointThreads();
   JSONStream js;
   timeline_recorder->PrintJSON(&js);
-  js.Steal(output, output_length);
+  // Resume execution of other threads.
   isolate->thread_registry()->ResumeAllThreads();
+
+  // Copy output.
+  char* output = NULL;
+  intptr_t output_length = 0;
+  js.Steal(const_cast<const char**>(&output), &output_length);
+  if (output != NULL) {
+    // Add one for the '\0' character.
+    output_length++;
+  }
+  // Start stream.
+  const char* kStreamName = "timeline";
+  const intptr_t kDataSize = 64 * KB;
+  consumer(DART_STREAM_CONSUMER_STATE_START,
+           kStreamName,
+           NULL,
+           0,
+           user_data);
+
+  // Stream out data.
+  intptr_t cursor = 0;
+  intptr_t remaining = output_length - cursor;

[siva, 2015/08/11 16:54:33]

intptr_t remaining = output_length;

[Cutch, 2015/08/11 17:08:56]

Done.

+  while (remaining >= kDataSize) {
+    consumer(DART_STREAM_CONSUMER_STATE_DATA,
+             kStreamName,
+             reinterpret_cast<uint8_t*>(&output[cursor]),
+             kDataSize,
+             user_data);
+    cursor += kDataSize;
+    remaining -= kDataSize;
+  }
+  if (remaining > 0) {
+    ASSERT(remaining < kDataSize);
+    consumer(DART_STREAM_CONSUMER_STATE_DATA,
+             kStreamName,
+             reinterpret_cast<uint8_t*>(&output[cursor]),
+             remaining,
+             user_data);
+    cursor += remaining;
+    remaining -= remaining;
+  }
+  ASSERT(cursor == output_length);
+  ASSERT(remaining == 0);
+
+  // Finish stream.
+  consumer(DART_STREAM_CONSUMER_STATE_FINISH,
+           kStreamName,
+           NULL,
+           0,
+           user_data);

[siva, 2015/08/11 16:54:33]

Why does start and end have to have a NULL buffer why can't they have a buffer
too (would reduce the number of callback calls to be made).

[Cutch, 2015/08/11 17:08:56]

I find this API simpler to work with. 

   return true;
 }
 
 
 DART_EXPORT Dart_Handle Dart_TimelineDuration(const char* label,
                                               int64_t start_micros,
                                               int64_t end_micros) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (label == NULL) {
@@ skipping 88 matching lines @@
   ASSERT(stream != NULL);
   TimelineEvent* event = stream->StartEvent();
   if (event != NULL) {
     event->AsyncEnd(label, async_id);
     event->Complete();
   }
   return Api::Success();
 }
 
 }  // namespace dart