Refactor Dart_TimelineGetTrace to use a StreamConsumer callback

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, 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 "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
@@ skipping 9261 matching lines @@
   Dart_TimelineAsyncEnd("testAsyncEvent", async_id);
 
   // Check that it is in the output.
   TimelineEventRecorder* recorder = isolate->timeline_event_recorder();
   JSONStream js;
   recorder->PrintJSON(&js);
   EXPECT_SUBSTRING("testAsyncEvent", js.ToCString());
 }
 
 
+struct AppendData {
+  uint8_t* buffer;
+  intptr_t buffer_length;
+};
+
+
+static void AppendStreamConsumer(intptr_t state,
+                                 const char* stream_name,
+                                 uint8_t* buffer,
+                                 intptr_t buffer_length,
+                                 void* user_data) {
+  if (state == DART_STREAM_CONSUMER_STATE_FINISH) {
+    return;
+  }
+  AppendData* data = reinterpret_cast<AppendData*>(user_data);
+  if (state == DART_STREAM_CONSUMER_STATE_START) {
+    // Initialize append data.
+    data->buffer = NULL;
+    data->buffer_length = 0;
+    return;
+  }
+  ASSERT(state == DART_STREAM_CONSUMER_STATE_DATA);
+  // Grow buffer.
+  data->buffer = reinterpret_cast<uint8_t*>(
+      realloc(data->buffer, data->buffer_length + buffer_length));
+  // Copy new data.
+  memmove(&data->buffer[data->buffer_length],
+          buffer,
+          buffer_length);
+  // Update length.
+  data->buffer_length += buffer_length;
+}
+
+
 TEST_CASE(Timeline_Dart_TimelineGetTrace) {
   const char* kScriptChars =
     "foo() => 'a';\n"
     "main() => foo();\n";
 
   Dart_Handle lib =
       TestCase::LoadTestScript(kScriptChars, NULL);
 
   const char* buffer = NULL;
   intptr_t buffer_length = 0;
   bool success = false;
 
   // Enable recording of all streams.
   Dart_TimelineSetRecordedStreams(DART_TIMELINE_STREAM_ALL);
 
   // Invoke main, which will be compiled resulting in a compiler event in
   // the timeline.
   Dart_Handle result = Dart_Invoke(lib,
                                    NewString("main"),
                                    0,
                                    NULL);
   EXPECT_VALID(result);
 
   // Grab the trace.
-  success = Dart_TimelineGetTrace(&buffer, &buffer_length);
+  AppendData data;
+  success = Dart_TimelineGetTrace(AppendStreamConsumer, &data);
   EXPECT(success);
+  buffer = reinterpret_cast<char*>(data.buffer);
+  buffer_length = data.buffer_length;
   EXPECT(buffer_length > 0);
   EXPECT(buffer != NULL);
+
   // Heartbeat test.
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"main\"", buffer);
-  // Free buffer acquired by Dart_TimelineGetTrace call.
-  free(const_cast<char*>(buffer));
+
+  // Free buffer allocated by AppendStreamConsumer
+  free(data.buffer);
 }
 
 }  // namespace dart