Adapt streams for additional stackTrace argument.

pkg/scheduled_test/lib/src/utils.dart

 // 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.
 
 library utils;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 11 matching lines @@
     return other.first == first && other.last == last;
   }
 
   int get hashCode => first.hashCode ^ last.hashCode;
 }
 
 /// Configures [future] so that its result (success or exception) is passed on
 /// to [completer].
 void chainToCompleter(Future future, Completer completer) {
   future.then((value) => completer.complete(value),
-      onError: (e) => completer.completeError(e));
+      onError: completer.completeError);
 }
 
 /// Prepends each line in [text] with [prefix]. If [firstPrefix] is passed, the
 /// first line is prefixed with that instead.
 String prefixLines(String text, {String prefix: '| ', String firstPrefix}) {
   var lines = text.split('\n');
   if (firstPrefix == null) {
     return lines.map((line) => '$prefix$line').join('\n');
   }
 
@@ skipping 35 matching lines @@
 Stream errorStream(error) => new Future.error(error).asStream();
 
 /// Returns a buffered stream that will emit the same values as the stream
 /// returned by [future] once [future] completes. If [future] completes to an
 /// error, the return value will emit that error and then close.
 Stream futureStream(Future<Stream> future) {
   var controller = new StreamController(sync: true);
   future.then((stream) {
     stream.listen(
         controller.add,
-        onError: (error) => controller.addError(error),
+        onError: controller.addError,
         onDone: controller.close);
   }).catchError((e) {
     controller.addError(e);
     controller.close();
   });
   return controller.stream;
 }
 
 /// Returns the first element of a [StreamIterator].
 ///
@@ skipping 37 matching lines @@
 /// Returns a wrapped version of [stream] along with a function that will cancel
 /// the wrapped stream. Unlike [StreamSubscription], this canceller will send a
 /// "done" message to the wrapped stream.
 Pair<Stream, StreamCanceller> streamWithCanceller(Stream stream) {
   var controller =
       stream.isBroadcast ? new StreamController.broadcast(sync: true)
                          : new StreamController(sync: true);
   var controllerStream = controller.stream;
   var subscription = stream.listen((value) {
     if (!controller.isClosed) controller.add(value);
-  }, onError: (error) {
-    if (!controller.isClosed) controller.addError(error);
+  }, onError: (error, [stackTrace]) {
+    if (!controller.isClosed) controller.addError(error, stackTrace);
   }, onDone: controller.close);
   return new Pair<Stream, StreamCanceller>(controllerStream, controller.close);
 }
 
 // TODO(nweiz): remove this when issue 7787 is fixed.
 /// Creates two single-subscription [Stream]s that each emit all values and
 /// errors from [stream]. This is useful if [stream] is single-subscription but
 /// multiple subscribers are necessary.
 Pair<Stream, Stream> tee(Stream stream) {
   var controller1 = new StreamController(sync: true);
   var controller2 = new StreamController(sync: true);
   stream.listen((value) {
     controller1.add(value);
     controller2.add(value);
-  }, onError: (error) {
-    controller1.addError(error);
-    controller2.addError(error);
+  }, onError: (error, [stackTrace]) {
+    controller1.addError(error, stackTrace);
+    controller2.addError(error, stackTrace);
   }, onDone: () {
     controller1.close();
     controller2.close();
   });
   return new Pair<Stream, Stream>(controller1.stream, controller2.stream);
 }
 
 /// Takes a simple data structure (composed of [Map]s, [Iterable]s, scalar
 /// objects, and [Future]s) and recursively resolves all the [Future]s contained
 /// within. Completes with the fully resolved structure.
@@ skipping 27 matching lines @@
 }
 
 /// Returns a string representation of [trace] that has the core and test frames
 /// folded together.
 String terseTraceString(StackTrace trace) {
   return new Trace.from(trace).terse.foldFrames((frame) {
     return frame.package == 'scheduled_test' || frame.package == 'unittest' ||
         frame.isCore;
   }).toString().trim();
 }