Change the HTTP close handling

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>();
 
   void add(_HttpConnectionBase connection) {
     void closeIfDone() {
-      // We only check for write closed here. This means that we are
-      // not waiting for the client to half-close the socket before
-      // fully closing the socket.
-      if (!connection._isWriteClosed) return;
+      // When either the client has closed or all data has been
+      // written to the client we close the underlying socket
+      // completely.
+      if (!connection._isWriteClosed && !connection._isReadClosed) return;

[Mads Ager (google), 2012/11/20 08:04:28]

Maybe remove the negations and make this:

if (connection._isWriteClosed || connection._isReadClose) {
  // do stuff
}

[Søren Gjesse, 2012/11/20 08:15:11]

Much better, done.

       _q.remove(connection);
       connection._socket.close();
       if (connection.onClosed != null) connection.onClosed();
     }
 
-    // If the connection is already fully closed don't insert it into the queue.
+    // If the connection is already fully closed don't insert it into
+    // 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
     // 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 (!connection._isReadClosed) {
       connection._socket.onClosed = () {
         connection._state |= _HttpConnectionBase.READ_CLOSED;
-        // This is a nop, as we are not using the read closed
-        // information for anything. For both server and client
-        // connections the inbound message have been read to
-        // completion when the socket enters the close queue.
         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();
     };
   }
 
   void shutdown() {
     _q.forEach((_HttpConnectionBase connection) {
       connection._socket.close();
     });
   }
@@ skipping 795 matching lines @@
     if (onRequestReceived != null) {
       onRequestReceived(_request, _response);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _request._onDataReceived(data);
   }
 
   void _checkDone() {
-    if (_isAllDone) {
-      // If we are done writing the response, and either the client
-      // has closed or 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.
+    if (_isReadClosed) {
+      // If the client closes the conversation is ended.
+      _server._closeQueue.add(this);
+    } else if (_isAllDone) {
+      // 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 (_isReadClosed || close) {
+      if (close) {
         _server._closeQueue.add(this);
       } else {
         _state = _HttpConnectionBase.IDLE;
       }
-    } else if (_state == _HttpConnectionBase.READ_CLOSED) {
-      // If entering READ_CLOSED state while idle close the connection.
-      _server._closeQueue.add(this);
     }
   }
 
   void _onDataEnd(bool close) {
     _request._onDataEnd();
     _state |= _HttpConnectionBase.REQUEST_DONE;
     _checkDone();
   }
 
   void _responseClosed() {
@@ skipping 1192 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;
 }