Reapply "Fixes to eventhandler and HTTP""

sdk/lib/io/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.
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
 class _CloseQueue {
   _CloseQueue() : _q = new Set<_HttpConnectionBase>();
@@ skipping 14 matching lines @@
     // the queue.
     if (connection._isFullyClosed) {
       connection._socket.close();
       if (connection.onClosed != null) connection.onClosed();
       return;
     }
 
     connection._state |= _HttpConnectionBase.CLOSING;
     _q.add(connection);
 
-    // If output stream is not closed for writing close it now and
+    // If the output stream is not closed for writing, close it now and
     // wait for callback when closed.
     if (!connection._isWriteClosed) {
       connection._socket.outputStream.close();
       connection._socket.outputStream.onClosed = () {
         connection._state |= _HttpConnectionBase.WRITE_CLOSED;
         closeIfDone();
       };
     } else {
       connection._socket.outputStream.onClosed = () { assert(false); };
     }
 
-    // If socket is not closed for reading wait for callback.
+    // If the request is not already fully read wait for the socket to close.
+    // As the _isReadClosed state from the HTTP request processing indicate
+    // that the response has been parsed this does not necesarily mean tha
+    // the socket is closed.
     if (!connection._isReadClosed) {
       connection._socket.onClosed = () {
         connection._state |= _HttpConnectionBase.READ_CLOSED;
         closeIfDone();
       };
-    } else {
-      connection._socket.onClosed = () { assert(false); };
     }
 
     // Ignore any data on a socket in the close queue.
     connection._socket.onData = connection._socket.read;
 
     // If an error occurs immediately close the socket.
     connection._socket.onError = (e) {
       connection._state |= _HttpConnectionBase.READ_CLOSED;
       connection._state |= _HttpConnectionBase.WRITE_CLOSED;
       closeIfDone();
@@ skipping 866 matching lines @@
       // If we are done writing the response, and the connection is
       // not persistent, we must close. Also if using HTTP 1.0 and the
       // content length was not known we must close to indicate end of
       // body.
       bool close =
           !_response.persistentConnection ||
           (_response._protocolVersion == "1.0" && _response._contentLength < 0);
       _request = null;
       _response = null;
       if (close) {
+        _httpParser.cancel();
         _server._closeQueue.add(this);
       } else {
         _state = _HttpConnectionBase.IDLE;
       }
     } else if (_isResponseDone && _hasBody) {
       // If the response is closed before the request is fully read
       // close this connection. If there is buffered output
       // (e.g. error response for invalid request where the server did
       // not care to read the request body) this is send.
       assert(!_isRequestDone);
       _writeBufferedResponse();
-      _close();
+      _httpParser.cancel();
       _server._closeQueue.add(this);
     }
   }
 
   void _onDataEnd(bool close) {
     // Start sending queued response if any.
     _state |= _HttpConnectionBase.REQUEST_DONE;
     _writeBufferedResponse();
     _request._onDataEnd();
     _checkDone();
@@ skipping 1361 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }