Change the error handling in dart:io

runtime/bin/socket_impl.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.
 
 
 class _SocketBase {
   // Bit flags used when communicating between the eventhandler and
   // dart code. The EVENT flags are used to indicate events of
   // interest when sending a message from dart code to the
   // eventhandler. When receiving a message from the eventhandler the
@@ skipping 81 matching lines @@
       _handler.close();
       _handler = null;
     } else {
       _activateHandlers();
     }
   }
 
   OSError _getError() native "Socket_GetError";
   int _getPort() native "Socket_GetPort";
 
-  void set onError(void callback(Exception e)) {
+  void set onError(void callback(e)) {
     _setHandler(_ERROR_EVENT, callback);
   }
 
   void _activateHandlers() {
     if (_canActivateHandlers && (_id >= 0)) {
       if (_handlerMask == 0) {
         if (_handler != null) {
           _handler.close();
           _handler = null;
         }
@@ skipping 68 matching lines @@
     if (_handler === null) {
       _handler = new ReceivePort();
       _handler.receive((var message, ignored) { _multiplex(message); });
     }
     assert(_id >= 0);
     _EventHandler._sendData(_id, _handler, data);
   }
 
   bool _reportError(error, String message) {
     void doReportError(Exception e) {
-      // Invoke the error callback if any.
+      // Invoke the socket error callback if any.
+      bool reported = false;
       if (_handlerMap[_ERROR_EVENT] != null) {
         _handlerMap[_ERROR_EVENT](e);
+        reported = true;
       }
       // Propagate the error to any additional listeners.
-      _propagateError(e);
+      reported = reported || _propagateError(e);
+      if (!reported) throw e;
     }
 
     // For all errors we close the socket, call the error handler and
     // disable further calls of the error handler.
     close();
     if (error is OSError) {
       doReportError(new SocketIOException(message, error));
     } else if (error is List) {
       assert(_isErrorResponse(error));
       switch (error[0]) {
         case _FileUtils.kIllegalArgumentResponse:
           doReportError(new IllegalArgumentException());
           break;
         case _FileUtils.kOSErrorResponse:
           doReportError(new SocketIOException(
               message, new OSError(error[2], error[1])));
           break;
         default:
           doReportError(new Exception("Unknown error"));
           break;
       }
     } else {
       doReportError(new SocketIOException(message));
     }
   }
 
   int hashCode() => _hashCode;
 
-  void _propagateError(Exception e) => null;
+  bool _propagateError(Exception e) => null;
 
   abstract bool _isListenSocket();
   abstract bool _isPipe();
 
   // Socket id is set from native. -1 indicates that the socket was closed.
   int _id;
 
   // Dedicated ReceivePort for socket events.
   ReceivePort _handler;
 
@@ skipping 273 matching lines @@
   }
 
   void set _onData(void callback()) {
     _setHandler(_SocketBase._IN_EVENT, callback);
   }
 
   void set _onClosed(void callback()) {
     _setHandler(_SocketBase._CLOSE_EVENT, callback);
   }
 
-  void _propagateError(Exception e) {
+  bool _propagateError(Exception e) {
+    bool reported = false;
     if (_inputStream != null) {
-      _inputStream._onError(e);
+      reported = reported || _inputStream._onSocketError(e);
     }
     if (_outputStream != null) {
-      _outputStream._onError(e);
+      reported = reported || _outputStream._onSocketError(e);
     }
+    return reported;
   }
 
   void _updateOutHandler() {
     void firstWriteHandler() {
       assert(!_seenFirstOutEvent);
       _seenFirstOutEvent = true;
 
       // From now on the write handler is only the client write
       // handler (connect handler cannot be called again). Change this
       // before calling any handlers as handlers can change the
@@ skipping 48 matching lines @@
   bool _seenFirstOutEvent = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
   String _remoteHost;
   int _remotePort;
   static SendPort _socketService;
 }