Change the error handling in dart:io

runtime/bin/http_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 _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 351 matching lines @@
 
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
   }
 
   int _streamReadInto(List<int> buffer, int offset, int len) {
     List<int> data = _buffer.readBytes(len);
     buffer.setRange(offset, data.length, data);
   }
 
-  void _streamSetErrorHandler(callback(Exception e)) {
+  void _streamSetErrorHandler(callback(e)) {
     _streamErrorHandler = callback;
   }
 
   String _method;
   String _uri;
   String _path;
   String _queryString;
   Map<String, String> _queryParameters;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
@@ skipping 67 matching lines @@
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection._onNoPendingWrites = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
-  void _streamSetErrorHandler(callback(Exception e)) {
+  void _streamSetErrorHandler(callback(e)) {
     _streamErrorHandler = callback;
   }
 
   String _findReasonPhrase(int statusCode) {
     if (_reasonPhrase != null) {
       return _reasonPhrase;
     }
 
     switch (statusCode) {
       case HttpStatus.CONTINUE: return "Continue";
@@ skipping 105 matching lines @@
   void pipe(OutputStream output, [bool close = true]) {
     _pipe(this, output, close: close);
   }
 
   List<int> _read(int bytesToRead) {
     List<int> result = _requestOrResponse._streamRead(bytesToRead);
     _checkScheduleCallbacks();
     return result;
   }
 
-  void set onError(void callback(Exception e)) {
+  void set onError(void callback(e)) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   int _readInto(List<int> buffer, int offset, int len) {
     int result = _requestOrResponse._streamReadInto(buffer, offset, len);
     _checkScheduleCallbacks();
     return result;
   }
 
   void _close() {
@@ skipping 28 matching lines @@
   }
 
   void set onNoPendingWrites(void callback()) {
     _requestOrResponse._streamSetNoPendingWriteHandler(callback);
   }
 
   void set onClosed(void callback()) {
     _requestOrResponse._streamSetCloseHandler(callback);
   }
 
-  void set onError(void callback(Exception e)) {
+  void set onError(void callback(e)) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 
 
 class _HttpConnectionBase implements Hashable {
   _HttpConnectionBase() : _sendBuffers = new Queue(),
                           _httpParser = new _HttpParser();
 
   void _connectionEstablished(Socket socket) {
     _socket = socket;
     // Register handler for socket events.
     _socket.onData = _onData;
     _socket.onClosed = _onClosed;
     _socket.onError = _onError;
+    // Ignore errors in the socket output stream as this is getting
+    // the same errors as the socket itself.
+    _socket.outputStream.onError = (e) => null;
   }
 
   bool _write(List<int> data, [bool copyBuffer = false]) {
     if (!_error && !_closing) {
       return _socket.outputStream.write(data, copyBuffer);
     }
   }
 
   bool _writeFrom(List<int> buffer, [int offset, int len]) {
     if (!_error && !_closing) {
@@ skipping 21 matching lines @@
         _close();
       }
     }
   }
 
   void _onClosed() {
     _closing = true;
     _onConnectionClosed(null);
   }
 
-  void _onError(Exception e) {
+  void _onError(e) {
     // If an error occurs, make sure to close the socket if one is associated.
     _error = true;
     if (_socket != null) {
       _socket.close();
     }
     _onConnectionClosed(e);
   }
 
-  abstract void _onConnectionClosed(Exception e);
+  abstract void _onConnectionClosed(e);
   abstract void _responseDone();
 
   void set _onNoPendingWrites(void callback()) {
     if (!_error) {
       _socket.outputStream.onNoPendingWrites = callback;
     }
   }
 
   int hashCode() => _socket.hashCode();
 
@@ skipping 16 matching lines @@
       (statusCode, reasonPhrase, version) =>
       _onResponseStart(statusCode, reasonPhrase, version);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (close) => _onDataEnd(close);
     _httpParser.error = (e) => _onError(e);
   }
 
-  void _onConnectionClosed(Exception e) {
-    if (e != null && onError != null) {
+  void _onConnectionClosed(e) {
+    // Don't report errors when HTTP parser is in idle state. Clients
+    // can close the connection and cause a connection reset by peer
+    // error which is OK.
+    if (e != null && onError != null && !_httpParser.isIdle) {
       onError(e);
       // Propagate the error to the streams.
       if (_request != null && _request._streamErrorHandler != null) {
         _request._streamErrorHandler(e);
       }
       if (_response != null && _response._streamErrorHandler != null) {
         _response._streamErrorHandler(e);
       }
     }
 
@@ skipping 97 matching lines @@
 
   void listenOn(ServerSocket serverSocket) {
     void onConnection(Socket socket) {
       // Accept the client connection.
       _HttpConnection connection = new _HttpConnection(this);
       connection._connectionEstablished(socket);
       connection.onRequestReceived = _handleRequest;
       connection.onClosed = () => _connections.remove(connection);
       connection.onError = (e) {
         _connections.remove(connection);
-        if (_onError != null) _onError(e);
+        if (_onError != null) {
+          _onError(e);
+        } else {
+          throw(e);
+        }
       };
       connection._connectionEstablished(socket);
       _connections.add(connection);
     }
     serverSocket.onConnection = onConnection;
     _server = serverSocket;
     _closeServer = false;
   }
 
   addRequestHandler(bool matcher(String path), Object handler) {
@@ skipping 18 matching lines @@
     _connections.clear();
   }
 
   int get port() {
     if (_server === null) {
       throw new HttpException("The HttpServer is not listening on a port.");
     }
     return _server.port;
   }
 
-  void set onError(void callback(Exception e)) {
+  void set onError(void callback(e)) {
     _onError = callback;
   }
 
   void _handleRequest(HttpRequest request, HttpResponse response) {
     for (int i = 0; i < _handlers.length; i++) {
       if (_handlers[i]._matcher(request)) {
         var handler = _handlers[i]._handler;
         try {
           handler.onRequest(request, response);
         } catch (var e) {
           if (_onError != null) {
             _onError(e);
+          } else {
+            throw e;
           }
         }
         return;
       }
     }
 
     if (_defaultHandler != null) {
       if (_defaultHandler is Function) {
         _defaultHandler(request, response);
       } else {
@@ skipping 67 matching lines @@
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
       _httpConnection._onNoPendingWrites = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
-  void _streamSetErrorHandler(callback(Exception e)) {
+  void _streamSetErrorHandler(callback(e)) {
     _streamErrorHandler = callback;
   }
 
   void _writeHeader() {
     List<int> data;
 
     // Write request line.
     data = _method.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
@@ skipping 80 matching lines @@
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
   }
 
   int _streamReadInto(List<int> buffer, int offset, int len) {
     List<int> data = _buffer.readBytes(len);
     buffer.setRange(offset, data.length, data);
     return data.length;
   }
 
-  void _streamSetErrorHandler(callback(Exception e)) {
+  void _streamSetErrorHandler(callback(e)) {
     _streamErrorHandler = callback;
   }
 
   int _statusCode;
   String _reasonPhrase;
 
   _HttpClientConnection _connection;
   _HttpInputStream _inputStream;
   _BufferList _buffer;
   Function _streamErrorHandler;
@@ skipping 35 matching lines @@
     _socketConn = null;
   }
 
   HttpClientRequest open(String method, String uri) {
     _method = method;
     _request = new _HttpClientRequest(method, uri, this);
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
-  void _onConnectionClosed(Exception e) {
+  void _onConnectionClosed(e) {
     // Socket is closed either due to an error or due to normal socket close.
     if (e != null) {
       if (_onErrorCallback != null) {
         _onErrorCallback(e);
       }
     }
     _closing = true;
     if (e != null) {
       // Propagate the error to the streams.
       if (_response != null && _response._streamErrorHandler != null) {
@@ skipping 34 matching lines @@
   }
 
   void set onRequest(void handler(HttpClientRequest request)) {
     _onRequest = handler;
   }
 
   void set onResponse(void handler(HttpClientResponse response)) {
     _onResponse = handler;
   }
 
-  void set onError(void callback(Exception e)) {
+  void set onError(void callback(e)) {
     _onErrorCallback = callback;
   }
 
   Function _onRequest;
   Function _onResponse;
   Function _onErrorCallback;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
@@ skipping 115 matching lines @@
     _HttpClientConnection connection = new _HttpClientConnection(this);
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
     Queue socketConnections = _openSockets[_connectionKey(host, port)];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
       // Until the connection is established handle connection errors
       // here as the HttpClientConnection object is not yet associated
       // with the socket.
-      socket.onError = (Exception e) {
+      socket.onError = (e) {
         // Report the error through the HttpClientConnection object to
         // the client.
         connection._onError(e);
       };
       socket.onConnect = () {
         // When the connection is established, clear the error
         // callback as it will now be handled by the
         // HttpClientConnection object which will be associated with
         // the connected socket.
         socket.onError = null;
@@ skipping 63 matching lines @@
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }