Adapt streams for additional stackTrace argument.

sdk/lib/_internal/pub/lib/src/error_group.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 pub.error_group;
 
 import 'dart:async';
 
 /// An [ErrorGroup] entangles the errors of multiple [Future]s and [Stream]s
 /// with one another. This allows APIs to expose multiple [Future]s and
@@ skipping 83 matching lines @@
     _streams.add(wrapped);
     return wrapped;
   }
 
   /// Sends [error] to all members of [this]. Like errors that come from
   /// members, this will only be passed to the top-level error handler if no
   /// members have listeners.
   ///
   /// If all members of [this] have already completed successfully or with an
   /// error, it's a [StateError] to try to signal an error.
-  void signalError(var error) {
+  void signalError(var error, [StackTrace stackTrace]) {
     if (_isDone) {
       throw new StateError("Can't signal errors on a complete ErrorGroup.");
     }
 
-    _signalError(error);
+    _signalError(error, stackTrace);
   }
 
   /// Signal an error internally. This is just like [signalError], but instead
   /// of throwing an error if [this] is complete, it just does nothing.
-  void _signalError(var error) {
+  void _signalError(var error, [StackTrace stackTrace]) {
     if (_isDone) return;
 
     var caught = false;
     for (var future in _futures) {
       if (future._isDone || future._hasListeners) caught = true;
-      future._signalError(error);
+      future._signalError(error, stackTrace);
     }
 
     for (var stream in _streams) {
       if (stream._isDone || stream._hasListeners) caught = true;
-      stream._signalError(error);
+      stream._signalError(error, stackTrace);
     }
 
     _isDone = true;
-    _done._signalError(error);
+    _done._signalError(error, stackTrace);
     if (!caught && !_done._hasListeners) runAsync((){ throw error; });
   }
 
   /// Notifies [this] that one of its member [Future]s is complete.
   void _signalFutureComplete(_ErrorGroupFuture future) {
     if (_isDone) return;
 
     _isDone = _futures.every((future) => future._isDone) &&
         _streams.every((stream) => stream._isDone);
     if (_isDone) _doneCompleter.complete();
@@ skipping 25 matching lines @@
   /// Whether [this] has any listeners.
   bool _hasListeners = false;
 
   /// Creates a new [_ErrorGroupFuture] that's a child of [_group] and wraps
   /// [inner].
   _ErrorGroupFuture(this._group, Future inner) {
     inner.then((value) {
       if (!_isDone) _completer.complete(value);
       _isDone = true;
       _group._signalFutureComplete(this);
-    }).catchError((error) => _group._signalError(error));
+    }).catchError(_group._signalError);
 
     // Make sure _completer.future doesn't automatically send errors to the
     // top-level.
     _completer.future.catchError((_) {});
   }
 
   Future then(onValue(value), {Function onError}) {
     _hasListeners = true;
     return _completer.future.then(onValue, onError: onError);
   }
 
   Future catchError(Function onError, {bool test(Object error)}) {
     _hasListeners = true;
     return _completer.future.catchError(onError, test: test);
   }
 
   Future whenComplete(void action()) {
     _hasListeners = true;
     return _completer.future.whenComplete(action);
   }
 
   Stream asStream() {
     _hasListeners = true;
     return _completer.future.asStream();
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
-  void _signalError(var error) {
-    if (!_isDone) _completer.completeError(error);
+  void _signalError(var error, [StackTrace stackTrace]) {
+    if (!_isDone) _completer.completeError(error, stackTrace);
     _isDone = true;
   }
 }
 
 // TODO(nweiz): currently streams never top-level unhandled errors (issue 7843).
 // When this is fixed, this class will need to prevent such errors from being
 // top-leveled.
 /// A [Stream] wrapper that keeps track of whether it's been completed and
 /// whether it has any listeners. It also notifies its parent [ErrorGroup] when
 /// it completes successfully or receives an error.
@@ skipping 22 matching lines @@
   /// [inner].
   _ErrorGroupStream(this._group, Stream inner)
     : _controller = new StreamController(sync: true) {
     // Use old-style asBroadcastStream behavior - cancel source _subscription
     // the first time the stream has no listeners.
     _stream = inner.isBroadcast
         ? _controller.stream.asBroadcastStream(onCancel: (sub) => sub.cancel())
         : _controller.stream;
     _subscription = inner.listen((v) {
       _controller.add(v);
-    }, onError: (e) {
-      _group._signalError(e);
+    }, onError: (e, [stackTrace]) {
+      _group._signalError(e, stackTrace);
     }, onDone: () {
       _isDone = true;
       _group._signalStreamComplete(this);
       _controller.close();
     });
   }
 
   StreamSubscription listen(void onData(value),
-      {void onError(var error), void onDone(),
+      {Function onError, void onDone(),
        bool cancelOnError}) {
     return _stream.listen(onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: true);
   }
 
   /// Signal that an error from [_group] should be propagated through [this],
   /// unless it's already complete.
-  void _signalError(var e) {
+  void _signalError(var e, [StackTrace stackTrace]) {
     if (_isDone) return;
     _subscription.cancel();
     // Call these asynchronously to work around issue 7913.
     new Future.value().then((_) {
-      _controller.addError(e);
+      _controller.addError(e, stackTrace);
       _controller.close();
     });
   }
 }