Improve the handling of the connection header

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 190 matching lines @@
     });
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     _headers.forEach((String name, List<String> values) {
       sb.add(name);
       sb.add(": ");
       for (int i = 0; i < values.length; i++) {
         if (i > 0) {
-          sb.add(": ");
+          sb.add(", ");
         }
         sb.add(values[i]);
       }
       sb.add("\n");
     });
     return sb.toString();
   }
 
   bool _mutable = true;  // Are the headers currently mutable?
   Map<String, List<String>> _headers;
 
   String _host;
   int _port;
 }
 
 
 class _HttpRequestResponseBase {
   final int START = 0;
   final int HEADER_SENT = 1;
   final int DONE = 2;
   final int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _headers = new _HttpHeaders() {
     _state = START;
   }
 
   int get contentLength() => _contentLength;
+  bool get persistentConnection() => _persistentConnection;
   HttpHeaders get headers() => _headers;
 
   bool _write(List<int> data, bool copyBuffer) {
     _ensureHeadersSent();
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
@@ skipping 90 matching lines @@
   _HttpHeaders _headers;
 
   // Length of the content body. If this is set to -1 (default value)
   // when starting to send data chunked transfer encoding will be
   // used.
   int _contentLength = -1;
   // Number of body bytes written. This is only actual body data not
   // including headers or chunk information of using chinked transfer
   // encoding.
   int _bodyBytesWritten = 0;
+
+  bool _persistentConnection = true;
 }
 
 
 // Parsed HTTP request providing information on the HTTP headers.
 class _HttpRequest extends _HttpRequestResponseBase implements HttpRequest {
   _HttpRequest(_HttpConnection connection) : super(connection);
 
   String get method() => _method;
   String get uri() => _uri;
   String get path() => _path;
@@ skipping 92 matching lines @@
     if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
   String get reasonPhrase() => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _reasonPhrase = reasonPhrase;
   }
 
+  void set persistentConnection(bool persistentConnection) {
+    if (_outputStream != null) throw new HttpException("Header already sent");
+    _persistentConnection = persistentConnection;
+  }
+
   OutputStream get outputStream() {
     if (_state >= DONE) throw new HttpException("Response closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   Socket detachSocket() {
     if (_state >= DONE) throw new HttpException("Response closed");
@@ skipping 115 matching lines @@
     _writeSP();
     data = _statusCode.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     data = reasonPhrase.charCodes();
     _httpConnection._write(data);
     _writeCRLF();
 
     // Determine the value of the "Connection" header.
     if (_protocolVersion == "1.1" && !_persistentConnection) {
-      _headers.set("Connection", "close");
+      _headers.add(HttpHeaders.CONNECTION, "close");
     } else if (_protocolVersion == "1.0" && _persistentConnection) {
-      _headers.set("Connection", "keep-alive");
+      _headers.add(HttpHeaders.CONNECTION, "keep-alive");
     }
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength > 0) {
-      _headers.set("Content-Length", _contentLength.toString());
+      _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
     } else {
-      _headers.set("Transfer-Encoding", "chunked");
+      _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADER_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
   String _protocolVersion;
-  bool _persistentConnection;
   _HttpOutputStream _outputStream;
   Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
   }
 
@@ skipping 234 matching lines @@
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     // TODO(sgjesse): Error handling.
   }
 
   void _onHeaderReceived(String name, String value) {
     _request._onHeaderReceived(name, value);
   }
 
   void _onHeadersComplete() {
     _request._onHeadersComplete();
+    _request._persistentConnection = _httpParser.persistentConnection;
     _response._persistentConnection = _httpParser.persistentConnection;
     if (onRequestReceived != null) {
       onRequestReceived(_request, _response);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _request._onDataReceived(data);
   }
 
@@ skipping 144 matching lines @@
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) {
     if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
+  void set persistentConnection(bool persistentConnection) {
+    if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
+    _persistentConnection = persistentConnection;
+  }
+
   OutputStream get outputStream() {
     if (_state == DONE) throw new HttpException("Request closed");
     if (_outputStream == null) {
       _outputStream = new _HttpOutputStream(this);
     }
     return _outputStream;
   }
 
   // Delegate functions for the HttpOutputStream implementation.
   bool _streamWrite(List<int> buffer, bool copyBuffer) {
@@ skipping 35 matching lines @@
     // Write request line.
     data = _method.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     data = _uri.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     _httpConnection._write(_Const.HTTP11);
     _writeCRLF();
 
+    // Determine the value of the "Connection" header.
+    if (!_persistentConnection) {
+      _headers.add(HttpHeaders.CONNECTION, "close");
+    }
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known. If there is no content
     // neither "Content-Length" nor "Transfer-Encoding" is set
     if (_contentLength > 0) {
-      _headers.set("Content-Length", _contentLength.toString());
+      _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
     } else if (_contentLength < 0) {
-      _headers.set("Transfer-Encoding", "chunked");
+      _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
     }
 
     // Write headers.
     _writeHeaders();
     _state = HEADER_SENT;
   }
 
   String _method;
   String _uri;
   _HttpClientConnection _connection;
@@ skipping 149 matching lines @@
 
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     _response._onResponseStart(statusCode, reasonPhrase, version);
   }
 
   void _onHeaderReceived(String name, String value) {
     _response._onHeaderReceived(name, value);
   }
 
   void _onHeadersComplete() {
+    _response._persistentConnection = _httpParser.persistentConnection;
     _response._onHeadersComplete();
   }
 
   void _onDataReceived(List<int> data) {
     _response._onDataReceived(data);
   }
 
   void _onDataEnd(bool close) {
     if (close) _closing = true;
     _response._onDataEnd();
@@ skipping 220 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?
 }