Improve the handling of HTTP requests with empty body

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 814 matching lines @@
       while (!_buffer.isEmpty) {
         var data = _buffer.first;
         _socket.outputStream.write(data, false);
         _buffer.removeBytes(data.length);
       }
       _buffer = null;
     }
   }
 
   bool _write(List<int> data, [bool copyBuffer = false]) {
-    if (_isRequestDone) {
+    if (_isRequestDone || !_hasBody || _httpParser.upgrade) {
       return _socket.outputStream.write(data, copyBuffer);
     } else {
       _bufferData(data, copyBuffer);
       return false;
     }
   }
 
   bool _writeFrom(List<int> data, [int offset, int len]) {
-    if (_isRequestDone) {
+    if (_isRequestDone || !_hasBody || _httpParser.upgrade) {
       return _socket.outputStream.writeFrom(data, offset, len);
     } else {
       if (offset == null) offset = 0;
       if (len == null) len = buffer.length - offset;
       _bufferData(data.getRange(offset, len), false);
       return false;
     }
   }
 
   bool _flush() {
@@ skipping 33 matching lines @@
     }
     if (_response != null && _response._streamErrorHandler != null) {
       _response._streamErrorHandler(e);
     }
     if (_socket != null) _socket.close();
   }
 
   void _onRequestReceived(String method,
                           String uri,
                           String version,
-                          _HttpHeaders headers) {
+                          _HttpHeaders headers,
+                          bool hasBody) {
     _state = _HttpConnectionBase.ACTIVE;
     // Create new request and response objects for this request.
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
     _request._onRequestReceived(method, uri, version, headers);
     _request._protocolVersion = version;
     _response._protocolVersion = version;
     _response._headResponse = method == "HEAD";
     _response.persistentConnection = _httpParser.persistentConnection;
+    _hasBody = hasBody;
     if (onRequestReceived != null) {
       onRequestReceived(_request, _response);
     }
+    _checkDone();
   }
 
   void _onDataReceived(List<int> data) {
     _request._onDataReceived(data);
+    _checkDone();
   }
 
   void _checkDone() {
     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 (close) {
         _server._closeQueue.add(this);
       } else {
         _state = _HttpConnectionBase.IDLE;
       }
-    } else if (_isResponseDone) {
+    } 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();
       _server._closeQueue.add(this);
     }
   }
 
   void _onDataEnd(bool close) {
     // Start sending queued response if any.
+    _state |= _HttpConnectionBase.REQUEST_DONE;
     _writeBufferedResponse();
-    _state |= _HttpConnectionBase.REQUEST_DONE;
     _request._onDataEnd();
+    _checkDone();
   }
 
   void _responseClosed() {
     _state |= _HttpConnectionBase.RESPONSE_DONE;
-    _checkDone();
   }
 
   HttpServer _server;
   HttpRequest _request;
   HttpResponse _response;
+  bool _hasBody = false;
 
   // Buffer for data written before full response has been processed.
   _BufferList _buffer;
 
   // Callbacks.
   Function onRequestReceived;
   Function onError;
 }
 
 
@@ skipping 334 matching lines @@
   InputStream get inputStream {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onResponseReceived(int statusCode,
                            String reasonPhrase,
                            String version,
-                           _HttpHeaders headers) {
+                           _HttpHeaders headers,
+                           bool hasBody) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
     _headers = headers;
     // Get parsed content length.
     _contentLength = _httpConnection._httpParser.contentLength;
 
     // Prepare for receiving data.
     _headers._mutable = false;
     _buffer = new _BufferList();
-
     if (isRedirect && _connection.followRedirects) {
       if (_connection._redirects == null ||
           _connection._redirects.length < _connection.maxRedirects) {
         // Check the location header.
         List<String> location = headers[HttpHeaders.LOCATION];
         if (location == null || location.length > 1) {
            throw new RedirectException("Invalid redirect",
                                        _connection._redirects);
         }
         // Check for redirect loop
@@ skipping 270 matching lines @@
         _onErrorCallback(e);
       } else {
         throw e;
       }
     }
   }
 
   void _onResponseReceived(int statusCode,
                            String reasonPhrase,
                            String version,
-                           _HttpHeaders headers) {
-    _response._onResponseReceived(statusCode, reasonPhrase, version, headers);
+                           _HttpHeaders headers,
+                          bool hasBody) {

[Mads Ager (google), 2012/12/11 07:04:34]

indentation off by 1 space?

[Søren Gjesse, 2012/12/11 07:26:31]

Done.

+    _response._onResponseReceived(
+        statusCode, reasonPhrase, version, headers, hasBody);
   }
 
   void _onDataReceived(List<int> data) {
     _response._onDataReceived(data);
   }
 
   void _onDataEnd(bool close) {
     _state |= _HttpConnectionBase.RESPONSE_DONE;
     _response._onDataEnd();
     _checkSocketDone();
@@ skipping 648 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;
 }