Adapt streams for additional stackTrace argument.

runtime/bin/socket_patch.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.
 
 patch class RawServerSocket {
   /* patch */ static Future<RawServerSocket> bind(address,
                                                   int port,
                                                   {int backlog: 0,
                                                    bool v6Only: false}) {
     return _RawServerSocket.bind(address, port, backlog, v6Only);
@@ skipping 683 matching lines @@
         if (socket != null) _controller.add(new _RawSocket(socket));
       },
       error: (e) {
         _controller.addError(e);
         _controller.close();
       }
     );
   }
 
   StreamSubscription<RawSocket> listen(void onData(RawSocket event),
-                                       {void onError(Object error),
+                                       {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
@@ skipping 79 matching lines @@
     native.isClosedWrite = true;
     if (fd != null) _getStdioHandle(native, fd);
     var result = new _RawSocket(native);
     result._isMacOSTerminalInput =
         Platform.isMacOS &&
         _StdIOUtils._socketType(result._socket) == _STDIO_HANDLE_TYPE_TERMINAL;
     return result;
   }
 
   StreamSubscription<RawSocketEvent> listen(void onData(RawSocketEvent event),
-                                            {void onError(Object error),
+                                            {Function onError,
                                              void onDone(),
                                              bool cancelOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 
   int available() => _socket.available();
@@ skipping 91 matching lines @@
                                     int port,
                                     int backlog,
                                     bool v6Only) {
     return _RawServerSocket.bind(address, port, backlog, v6Only)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
-                                    {void onError(error),
+                                    {Function onError,
                                      void onDone(),
                                      bool cancelOnError}) {
     return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
@@ skipping 27 matching lines @@
     streamCompleter = new Completer<Socket>();
     if (socket._raw != null) {
       subscription = stream.listen(
           (data) {
             assert(!paused);
             assert(buffer == null);
             buffer = data;
             offset = 0;
             write();
           },
-          onError: (error) {
+          onError: (error, [stackTrace]) {
             socket._consumerDone();
-            done(error);
+            done(error, stackTrace);
           },
           onDone: () {
             done();
           },
           cancelOnError: true);
     }
     return streamCompleter.future;
   }
 
   Future<Socket> close() {
@@ skipping 20 matching lines @@
           subscription.resume();
         }
       }
     } catch (e) {
       stop();
       socket._consumerDone();
       done(e);
     }
   }
 
-  void done([error]) {
+  void done([error, stackTrace]) {
     if (streamCompleter != null) {
       if (error != null) {
-        streamCompleter.completeError(error);
+        streamCompleter.completeError(error, stackTrace);
       } else {
         streamCompleter.complete(socket);
       }
       streamCompleter = null;
     }
   }
 
   void stop() {
     if (subscription == null) return;
     subscription.cancel();
@@ skipping 34 matching lines @@
     return new _Socket(new _RawSocket._writePipe(fd));
   }
 
   factory _Socket._readPipe([int fd]) {
     return new _Socket(new _RawSocket._readPipe(fd));
   }
 
   _NativeSocket get _nativeSocket => _raw._socket;
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
-                                       {void onError(error),
+                                       {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     return _controller.stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 
   Encoding get encoding => _sink.encoding;
@@ skipping 106 matching lines @@
   }
 
   void _onDone() {
     if (!_controllerClosed) {
       _controllerClosed = true;
       _controller.close();
     }
     _consumer.done();
   }
 
-  void _onError(error) {
+  void _onError(error, stackTrace) {
     if (!_controllerClosed) {
       _controllerClosed = true;
-      _controller.addError(error);
+      _controller.addError(error, stackTrace);
       _controller.close();
     }
-    _consumer.done(error);
+    _consumer.done(error, stackTrace);
   }
 
   int _write(List<int> data, int offset, int length) =>
       _raw.write(data, offset, length);
 
   void _enableWriteEvent() {
     _raw.writeEventsEnabled = true;
   }
 
   void _disableWriteEvent() {
     if (_raw != null) {
       _raw.writeEventsEnabled = false;
     }
   }
 
   void _consumerDone() {
     if (_detachReady != null) {
       _detachReady.complete(null);
     } else {
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 }