Adapt streams for additional stackTrace argument.

sdk/lib/io/websocket_impl.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.
 
 part of dart.io;
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
@@ skipping 81 matching lines @@
               if (_currentMessageType != _WebSocketMessageType.NONE) {
                 throw new WebSocketException("Protocol error");
               }
               _currentMessageType = _WebSocketMessageType.TEXT;
               _controller = new StreamController(sync: true);
               _controller.stream
                   .transform(UTF8.decoder)
                   .fold(new StringBuffer(), (buffer, str) => buffer..write(str))
                   .then((buffer) {
                     sink.add(buffer.toString());
-                  }, onError: (error) {
-                    sink.addError(error);
-                  });
+                  }, onError: sink.addError);
               break;
 
             case _WebSocketOpcode.BINARY:
               if (_currentMessageType != _WebSocketMessageType.NONE) {
                 throw new WebSocketException("Protocol error");
               }
               _currentMessageType = _WebSocketMessageType.BINARY;
               _controller = new StreamController(sync: true);
               _controller.stream
                   .fold(new BytesBuilder(), (buffer, data) => buffer..add(data))
                   .then((buffer) {
                     sink.add(buffer.takeBytes());
-                  }, onError: (error) {
-                    sink.addError(error);
-                  });
+                  }, onError: sink.addError);
               break;
 
             case _WebSocketOpcode.CLOSE:
             case _WebSocketOpcode.PING:
             case _WebSocketOpcode.PONG:
               // Control frames cannot be fragmented.
               if (!_fin) throw new WebSocketException("Protocol error");
               break;
 
             default:
@@ skipping 245 matching lines @@
 
 
 class _WebSocketTransformerImpl implements WebSocketTransformer {
   final StreamController<WebSocket> _controller =
       new StreamController<WebSocket>(sync: true);
 
   Stream<WebSocket> bind(Stream<HttpRequest> stream) {
     stream.listen((request) {
         _upgrade(request)
             .then((WebSocket webSocket) => _controller.add(webSocket))
-            .catchError((error) => _controller.addError(error));
+            .catchError(_controller.addError);
     });
 
     return _controller.stream;
   }
 
   static Future<WebSocket> _upgrade(HttpRequest request) {
     var response = request.response;
     if (!_isUpgradeRequest(request)) {
       // Send error response and drain the request.
       request.listen((_) {}, onDone: () {
@@ skipping 217 matching lines @@
     _controller = new StreamController(sync: true,
                                        onPause: _onPause,
                                        onResume: _onResume,
                                        onCancel: _onListen);
     var stream = _controller.stream.transform(
         new _WebSocketOutgoingTransformer(webSocket));
     socket.addStream(stream)
         .then((_) {
           _done();
           _closeCompleter.complete(webSocket);
-        }, onError: (error) {
+        }, onError: (error, StackTrace stackTrace) {
           _closed = true;
           _cancel();
           if (error is ArgumentError) {
-            if (!_done(error)) {
-              _closeCompleter.completeError(error);
+            if (!_done(error, stackTrace)) {
+              _closeCompleter.completeError(error, stackTrace);
             }
           } else {
             _done();
             _closeCompleter.complete(webSocket);
           }
         });
   }
 
-  bool _done([error]) {
+  bool _done([error, StackTrace stackTrace]) {
     if (_completer == null) return false;
     if (error != null) {
-      _completer.completeError(error);
+      _completer.completeError(error, stackTrace);
     } else {
       _completer.complete(webSocket);
     }
     _completer = null;
     return true;
   }
 
   Future addStream(var stream) {
     if (_closed) {
       stream.listen(null).cancel();
       return new Future.value(webSocket);
     }
     _ensureController();
     _completer = new Completer();
     _subscription = stream.listen(
         (data) {
           _controller.add(data);
         },
-        onDone: () {
-          _done();
-        },
-        onError: (error) {
-          _done(error);
-        },
+        onDone: _done,
+        onError: _done,
         cancelOnError: true);
     if (_issuedPause) {
       _subscription.pause();
       _issuedPause = false;
     }
     return _completer.future;
   }
 
   Future close() {
     _ensureController();
@@ skipping 150 matching lines @@
         },
         cancelOnError: true);
     _subscription.pause();
     _controller = new StreamController(sync: true,
                                        onListen: _subscription.resume,
                                        onPause: _subscription.pause,
                                        onResume: _subscription.resume);
   }
 
   StreamSubscription listen(void onData(message),
-                            {void onError(error),
+                            {Function onError,
                              void onDone(),
                              bool cancelOnError}) {
     return _controller.stream.listen(onData,
                                      onError: onError,
                                      onDone: onDone,
                                      cancelOnError: cancelOnError);
   }
 
   Duration get pingInterval => _pingInterval;
 
@@ skipping 52 matching lines @@
            (code < WebSocketStatus.NORMAL_CLOSURE ||
             code == WebSocketStatus.RESERVED_1004 ||
             code == WebSocketStatus.NO_STATUS_RECEIVED ||
             code == WebSocketStatus.ABNORMAL_CLOSURE ||
             (code > WebSocketStatus.INTERNAL_SERVER_ERROR &&
              code < WebSocketStatus.RESERVED_1015) ||
             (code >= WebSocketStatus.RESERVED_1015 &&
              code < 3000));
   }
 }