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;
@@ skipping 10 matching lines @@
   final int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _headers = new _HttpHeaders() {
     _state = START;
   }
 
   int get contentLength() => _contentLength;
   HttpHeaders get headers() => _headers;
 
+  bool get persistentConnection() {
+    List<String> connection = headers[HttpHeaders.CONNECTION];
+    if (_protocolVersion == "1.1") {
+      if (connection == null) return true;
+      return !headers[HttpHeaders.CONNECTION].some(
+          (value) => value.toLowerCase() == "close");
+    } else {
+      if (connection == null) return false;
+      return headers[HttpHeaders.CONNECTION].some(
+          (value) => value.toLowerCase() == "keep-alive");
+    }
+  }
+
+  void set persistentConnection(bool persistentConnection) {
+    if (_outputStream != null) throw new HttpException("Header already sent");
+
+    // Determine the value of the "Connection" header.
+    headers.remove(HttpHeaders.CONNECTION, "close");
+    headers.remove(HttpHeaders.CONNECTION, "keep-alive");
+    if (_protocolVersion == "1.1" && !persistentConnection) {
+      headers.add(HttpHeaders.CONNECTION, "close");
+    } else if (_protocolVersion == "1.0" && persistentConnection) {
+      headers.add(HttpHeaders.CONNECTION, "keep-alive");
+    }
+  }
+
+
   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();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
@@ skipping 79 matching lines @@
     if (_bodyBytesWritten + bytes > _contentLength) {
       throw new HttpException("Writing more than specified content length");
     }
     _bodyBytesWritten += bytes;
   }
 
   int _state;
 
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
+  String _protocolVersion = "1.1";
 
   // 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;
 }
@@ skipping 234 matching lines @@
       _httpConnection._write(_Const.HTTP10);
     }
     _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");
-    } else if (_protocolVersion == "1.0" && _persistentConnection) {
-      _headers.set("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 221 matching lines @@
       // Indicate connection close to the HTTP parser.
       _httpParser.connectionClosed();
     }
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // Create new request and response objects for this request.
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
     _request._onRequestStart(method, uri, version);
+    _request._protocolVersion = version;
     _response._protocolVersion = version;
   }
 
   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();
-    _response._persistentConnection = _httpParser.persistentConnection;
+    _response.persistentConnection = _httpParser.persistentConnection;
     if (onRequestReceived != null) {
       onRequestReceived(_request, _response);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _request._onDataReceived(data);
   }
 
   void _onDataEnd(bool close) {
@@ skipping 202 matching lines @@
     data = _uri.toString().charCodes();
     _httpConnection._write(data);
     _writeSP();
     _httpConnection._write(_Const.HTTP11);
     _writeCRLF();
 
     // 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 389 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?
 }