Adapt streams for additional stackTrace argument.

sdk/lib/_internal/pub/lib/src/utils.dart

 // 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.
 
 /// Generic utility functions. Stuff that should possibly be in core.
 library pub.utils;
 
 import 'dart:async';
 import "dart:collection";
 import "dart:convert";
@@ skipping 285 matching lines @@
 /// emitted, the returned Future completes to that error.
 Future<Stream> validateStream(Stream stream) {
   var completer = new Completer<Stream>();
   var controller = new StreamController(sync: true);
 
   StreamSubscription subscription;
   subscription = stream.listen((value) {
     // We got a value, so the stream is valid.
     if (!completer.isCompleted) completer.complete(controller.stream);
     controller.add(value);
-  }, onError: (error) {
+  }, onError: (error, [StackTrace stackTrace]) {
     // If the error came after values, it's OK.
     if (completer.isCompleted) {
-      controller.addError(error);
+      controller.addError(error, stackTrace);
       return;
     }
 
     // Otherwise, the error came first and the stream is invalid.
-    completer.completeError(error);
+    completer.completeError(error, stackTrace);
 
     // We don't be returning the stream at all in this case, so unsubscribe
     // and swallow the error.
     subscription.cancel();
   }, onDone: () {
     // It closed with no errors, so the stream is valid.
     if (!completer.isCompleted) completer.complete(controller.stream);
     controller.close();
   });
 
   return completer.future;
 }
 
 // TODO(nweiz): remove this when issue 7964 is fixed.
 /// Returns a [Future] that will complete to the first element of [stream].
 /// Unlike [Stream.first], this is safe to use with single-subscription streams.
 Future streamFirst(Stream stream) {
   var completer = new Completer();
   var subscription;
   subscription = stream.listen((value) {
     subscription.cancel();
     completer.complete(value);
-  }, onError: (e) {
-    completer.completeError(e);
+  }, onError: (e, [StackTrace stackTrace]) {
+    completer.completeError(e, stackTrace);
   }, onDone: () {
     completer.completeError(new StateError("No elements"));
   }, cancelOnError: true);
   return completer.future;
 }
 
 /// Returns a wrapped version of [stream] along with a [StreamSubscription] that
 /// can be used to control the wrapped stream.
 Pair<Stream, StreamSubscription> streamWithSubscription(Stream stream) {
   var controller =
       stream.isBroadcast ? new StreamController.broadcast(sync: true)
                          : new StreamController(sync: true);
   var subscription = stream.listen(controller.add,
       onError: controller.addError,
       onDone: controller.close);
   return new Pair<Stream, StreamSubscription>(controller.stream, subscription);
 }
 
 // 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 stackTrace]) {
+    controller1.addError(error, stackTrace);
+    controller2.addError(error, stackTrace);
   }, onDone: () {
     controller1.close();
     controller2.close();
   });
   return new Pair<Stream, Stream>(controller1.stream, controller2.stream);
 }
 
 /// Merges [stream1] and [stream2] into a single stream that emits events from
 /// both sources.
 Stream mergeStreams(Stream stream1, Stream stream2) {
   var doneCount = 0;
   var controller = new StreamController(sync: true);
 
   for (var stream in [stream1, stream2]) {
     stream.listen((value) {
       controller.add(value);
-    }, onError: (error) {
-      controller.addError(error);
+    }, onError: (error, [StackTrace stackTrace]) {
+      controller.addError(error, stackTrace);
     }, onDone: () {
       doneCount++;
       if (doneCount == 2) controller.close();
     });
   }
 
   return controller.stream;
 }
 
 /// A regular expression matching a trailing CR character.
@@ skipping 337 matching lines @@
     error is DirectoryException ||
     error is FileException ||
     error is HttpException ||
     error is HttpException ||
     error is LinkException ||
     error is OSError ||
     error is ProcessException ||
     error is SocketException ||
     error is WebSocketException;
 }