Extend dart:io error handling to all socket functions

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 46 matching lines @@
         if (eventHandler != null) {
           // Unregister the out handler before executing it.
           if (i == _OUT_EVENT) _setHandler(i, null);
 
           // Don't call the in handler if there is no data available
           // after all.
           if ((i == _IN_EVENT) && (this is _Socket) && (available() == 0)) {
             continue;
           }
           if (i == _ERROR_EVENT) {
-            eventHandler(new SocketIOException(""));
+            eventHandler(new SocketIOException("", _getError()));
             close();
           } else {
             eventHandler();
           }
         }
       }
     }
     _canActivateHandlers = true;
     _activateHandlers();
   }
@@ skipping 11 matching lines @@
         _closedRead &&
         _handlerMask == 0 &&
         _handler != null) {
       _handler.close();
       _handler = null;
     } else {
       _activateHandlers();
     }
   }
 
+  OSError _getError() native "Socket_GetError";
   int _getPort() native "Socket_GetPort";
 
   void set onError(void callback(Exception e)) {
     _setHandler(_ERROR_EVENT, callback);
   }
 
   void _activateHandlers() {
     if (_canActivateHandlers && (_id >= 0)) {
       if (_handlerMask == 0) {
         if (_handler != null) {
@@ skipping 69 matching lines @@
 
   void _sendToEventHandler(int data) {
     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) {
+    // For all errors we close the socket, call the error handler and
+    // disable further calls of the error handler.
+    close();
+    var onError = _handlerMap[_ERROR_EVENT];
+    if (onError != null) {
+      if (error is OSError) {
+        onError(new SocketIOException(message, error));
+      } else if (error is List) {
+        assert(_isErrorResponse(error));
+        switch (error[0]) {
+          case _FileUtils.kIllegalArgumentResponse:
+            onError(new IllegalArgumentException());
+            break;
+          case _FileUtils.kOSErrorResponse:
+            onError(new SocketIOException(
+                message, new OSError(error[2], error[1])));
+            break;
+          default:
+            onError(new Exception("Unknown error"));
+            break;
+        }
+      } else {
+        onError(new SocketIOException(message));
+      }
+    }
+  }
+
   int hashCode() => _hashCode;
 
   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 19 matching lines @@
 
 
 class _ServerSocket extends _SocketBase implements ServerSocket {
   // Constructor for server socket. First a socket object is allocated
   // in which the native socket is stored. After that _createBind
   // is called which creates a file descriptor and binds the given address
   // and port to the socket. Null is returned if file descriptor creation or
   // bind failed.
   factory _ServerSocket(String bindAddress, int port, int backlog) {
     _ServerSocket socket = new _ServerSocket._internal();
-    if (!socket._createBindListen(bindAddress, port, backlog)) {
+    var result = socket._createBindListen(bindAddress, port, backlog);
+    if (result is OSError) {
       socket.close();
-      return null;
+      throw new SocketIOException("Failed to create server socket", result);
     }
+    assert(result);
     if (port != 0) {
       socket._port = port;
     }
     return socket;
   }
 
   _ServerSocket._internal();
 
   bool _accept(Socket socket) native "ServerSocket_Accept";
 
   bool _createBindListen(String bindAddress, int port, int backlog)
       native "ServerSocket_CreateBindListen";
 
   void set onConnection(void callback(Socket connection)) {
     _clientConnectionHandler = callback;
     _setHandler(_IN_EVENT,
                 _clientConnectionHandler != null ? _connectionHandler : null);
   }
 
   void _connectionHandler() {
     if (_id >= 0) {
       _Socket socket = new _Socket._internal();
-      if (_accept(socket)) _clientConnectionHandler(socket);
+      var result = _accept(socket);
+      if (result is OSError) {
+        _reportError(result, "Accept failed");
+      } else {
+        _clientConnectionHandler(socket);
+      }
     }
   }
 
   bool _isListenSocket() => true;
   bool _isPipe() => false;
 
   var _clientConnectionHandler;
 }
 
 
 class _Socket extends _SocketBase implements Socket {
   static final kSuccessResponse = 0;
   static final kIllegalArgumentResponse = 1;
   static final kOSErrorResponse = 2;
 
   static final kHostNameLookup = 0;
 
   // Constructs a new socket. During the construction an asynchronous
   // host name lookup is initiated. The returned socket is not yet
   // connected but ready for registration of callbacks.
   factory _Socket(String host, int port) {
     Socket socket = new _Socket._internal();
     _ensureSocketService();
     List request = new List(2);
     request[0] = kHostNameLookup;
     request[1] = host;
     _socketService.call(request).then((response) {
       if (socket._isErrorResponse(response)) {
         socket._reportError(response, "Failed host name lookup");
-      } else {
-        if (!socket._createConnect(response, port)) {
+      } else{
+        var result = socket._createConnect(response, port);
+        if (result is OSError) {
           socket.close();
-          socket._reportError(null, "Connection failed");
+          socket._reportError(result, "Connection failed");
         } else {
           socket._activateHandlers();
         }
       }
     });
     return socket;
   }
 
   _Socket._internal();
   _Socket._internalReadOnly() : _pipe = true { super._closedWrite = true; }
@@ skipping 17 matching lines @@
       if (offset < 0) {
         throw new IndexOutOfRangeException(offset);
       }
       if (bytes < 0) {
         throw new IndexOutOfRangeException(bytes);
       }
       if ((offset + bytes) > buffer.length) {
         throw new IndexOutOfRangeException(offset + bytes);
       }
       int result = _readList(buffer, offset, bytes);
-      if (result < 0) {
-        _reportError(null, "Read failed");
+      if (result is OSError) {
+        _reportError(result, "Read failed");
+        return -1;
       }
       return result;
     }
     throw new
         SocketIOException("Error: readList failed - invalid socket handle");
   }
 
   int _readList(List<int> buffer, int offset, int bytes)
       native "Socket_ReadList";
 
@@ skipping 25 matching lines @@
         for (int i = 0; i < bytes; i++) {
           int value = buffer[j];
           if (value is! int) {
             throw new FileIOException(
                 "List element is not an integer at index $j");
           }
           outBuffer[i] = value;
           j++;
         }
       }
-      var bytes_written = _writeList(outBuffer, outOffset, bytes);
-      if (bytes_written < 0) {
+      var result = _writeList(outBuffer, outOffset, bytes);
+      if (result is OSError) {
         // If writing fails we return 0 as the number of bytes and
         // report the error on the error handler.
-        bytes_written = 0;
-        _reportError(null, "Write failed");
+        result = 0;
+        _reportError(result, "Write failed");
       }
-      return bytes_written;
+      return result;
     }
-    throw new
-        SocketIOException("Error: writeList failed - invalid socket handle");
+    throw new SocketIOException("writeList failed - invalid socket handle");
   }
 
   int _writeList(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
 
   bool _isErrorResponse(response) {
     return response is List && response[0] != _FileUtils.kSuccessResponse;
   }
 
-  bool _reportError(response, String message) {
-    if (response != null) {
-      assert(_isErrorResponse(response));
-    }
-    // For all errors we close the socket, call the error handler and
-    // disable further calls of the error handler.
-    close();
-    var onError = _handlerMap[_ERROR_EVENT];
-    if (onError != null) {
-      if (response != null) {
-        switch (response[0]) {
-          case _FileUtils.kIllegalArgumentResponse:
-            onError(new IllegalArgumentException());
-            break;
-          case _FileUtils.kOSErrorResponse:
-            onError(new SocketIOException(
-                message, new OSError(response[2], response[1])));
-            break;
-          default:
-            onError(new Exception("Unknown error"));
-            break;
-        }
-      } else {
-        onError(new SocketIOException(message));
-      }
-    }
-  }
-
   bool _createConnect(String host, int port) native "Socket_CreateConnect";
 
   void set onWrite(void callback()) {
     if (_outputStream != null) throw new StreamException(
             "Cannot set write handler when output stream is used");
     _clientWriteHandler = callback;
     _updateOutHandler();
   }
 
   void set onConnect(void callback()) {
@@ skipping 99 matching lines @@
   }
 
   bool _seenFirstOutEvent = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
   static SendPort _socketService;
 }