Add HTTP/1.0 support and simplify persistent connections handling

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 _HttpRequestResponseBase {
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _contentLength = -1,
-        _keepAlive = false,
         _headers = new Map();
 
   int get contentLength() => _contentLength;
-  bool get keepAlive() => _keepAlive;
   Map get headers() => _headers;
 
   void _setHeader(String name, String value) {
     _headers[name.toLowerCase()] = value;
   }
 
   bool _write(List<int> data, bool copyBuffer) {
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
@@ skipping 75 matching lines @@
     return _httpConnection._write(SP);
   }
 
   _HttpConnectionBase _httpConnection;
   Map<String, String> _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;
-  bool _keepAlive;
 }
 
 
 // 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;
   String get queryString() => _queryString;
   Map get queryParameters() => _queryParameters;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
-  void _onRequestStart(String method, String uri) {
+  void _onRequestStart(String method, String uri, String version) {
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
   void _onHeaderReceived(String name, String value) {
     _setHeader(name, value);
   }
 
   void _onHeadersComplete() {
@@ skipping 63 matching lines @@
   _HttpResponse(_HttpConnection httpConnection)
       : super(httpConnection),
         _statusCode = HttpStatus.OK,
         _state = START;
 
   void set contentLength(int contentLength) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
-  void set keepAlive(bool keepAlive) {
-    if (_outputStream != null) throw new HttpException("Header already sent");
-    _keepAlive = keepAlive;
-  }
-
   int get statusCode() => _statusCode;
   void set statusCode(int statusCode) {
     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;
@@ skipping 121 matching lines @@
       case HttpStatus.HTTP_VERSION_NOT_SUPPORTED:
         return "Http Version not supported";
       default: return "Status $statusCode";
     }
   }
 
   bool _writeHeader() {
     List<int> data;
 
     // Write status line.
-    _httpConnection._write(_Const.HTTP11);
+    if (_protocolVersion == "1.1") {
+      _httpConnection._write(_Const.HTTP11);
+    } else {
+      _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
-    // based on the keep alive state.
-    setHeader("Connection", keepAlive ? "keep-alive" : "close");
+    // Determine the value of the "Connection" header.
+    if (_protocolVersion == "1.1" && !_persistentConnection) {
+      setHeader("Connection", "close");
+    } else if (_protocolVersion == "1.0" && _persistentConnection) {
+      setHeader("Connection", "keep-alive");
+    }
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       setHeader("Content-Length", _contentLength.toString());
     } else {
       setHeader("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADERS_SENT;
     return allWritten;
   }
 
   // Response status code.
   int _statusCode;
   String _reasonPhrase;
+  String _protocolVersion;
   Date _expires;
+  bool _persistentConnection;
   _HttpOutputStream _outputStream;
   int _state;
   Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
   }
@@ skipping 147 matching lines @@
 
   Queue _sendBuffers;
 }
 
 
 // HTTP server connection over a socket.
 class _HttpConnection extends _HttpConnectionBase {
   _HttpConnection(HttpServer this._server) {
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
-        (method, uri) => _onRequestStart(method, uri);
+      (method, uri, version) => _onRequestStart(method, uri, version);
     _httpParser.responseStart =
-        (statusCode, reasonPhrase) =>
-            _onResponseStart(statusCode, reasonPhrase);
+      (statusCode, reasonPhrase, version) =>
+      _onResponseStart(statusCode, reasonPhrase, version);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (close) => _onDataEnd(close);
     _httpParser.error = (e) => _onError(e);
   }
 
   void _onConnectionClosed(Exception e) {
     if (e != null && onError != null) {
@@ skipping 17 matching lines @@
       return;
     }
 
     // Processing a request.
     if (e == null) {
       // Indicate connection close to the HTTP parser.
       _httpParser.connectionClosed();
     }
   }
 
-  void _onRequestStart(String method, String uri) {
+  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);
+    _request._onRequestStart(method, uri, version);
+    _response._protocolVersion = version;
   }
 
-  void _onResponseStart(int statusCode, String reasonPhrase) {
+  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.keepAlive = _httpParser.keepAlive;
+    _response._persistentConnection = _httpParser.persistentConnection;
     if (onRequestReceived != null) {
       onRequestReceived(_request, _response);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _request._onDataReceived(data);
   }
 
   void _onDataEnd(bool close) {
@@ skipping 98 matching lines @@
       : super(connection),
         _state = START {
     _connection = connection;
     // Default GET requests to have no content.
     if (_method == "GET") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) => _contentLength = contentLength;
-  void set keepAlive(bool keepAlive) => _keepAlive = keepAlive;
 
   String get host() => _host;
   void set host(String host) {
     _host = host;
     _updateHostHeader();
   }
 
   int get port() => _port;
   void set port(int port) {
     _port = port;
@@ skipping 75 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
-    // based on the keep alive state.
-    setHeader("Connection", keepAlive ? "keep-alive" : "close");
     // Determine the value of the "Transfer-Encoding" header based on
     // whether the content length is known.
     if (_contentLength >= 0) {
       setHeader("Content-Length", _contentLength.toString());
     } else {
       setHeader("Transfer-Encoding", "chunked");
     }
 
     // Write headers.
     _writeHeaders();
@@ skipping 29 matching lines @@
 
   Map get headers() => _headers;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
-  void _onRequestStart(String method, String uri) {
+  void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling
   }
 
-  void _onResponseStart(int statusCode, String reasonPhrase) {
+  void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
   }
 
   void _onHeaderReceived(String name, String value) {
     _setHeader(name, value);
   }
 
   void _onHeadersComplete() {
     _buffer = new _BufferList();
@@ skipping 43 matching lines @@
 
 class _HttpClientConnection
     extends _HttpConnectionBase implements HttpClientConnection {
   _HttpClientConnection(_HttpClient this._client);
 
   void _connectionEstablished(_SocketConnection socketConn) {
     super._connectionEstablished(socketConn._socket);
     _socketConn = socketConn;
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
-        (method, uri) => _onRequestStart(method, uri);
+      (method, uri, version) => _onRequestStart(method, uri, version);
     _httpParser.responseStart =
-        (statusCode, reasonPhrase) =>
-            _onResponseStart(statusCode, reasonPhrase);
+      (statusCode, reasonPhrase, version) =>
+      _onResponseStart(statusCode, reasonPhrase, version);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (closed) => _onDataEnd(closed);
     _httpParser.error = (e) => _onError(e);
     // Tell the HTTP parser the method it is expecting a response to.
     _httpParser.responseToMethod = _method;
   }
 
   void _responseDone() {
     if (_closing) {
       if (_socket != null) {
         _socket.close();
       }
     } else {
       _client._returnSocketConnection(_socketConn);
     }
     _socket = null;
     _socketConn = null;
   }
 
   HttpClientRequest open(String method, String uri) {
     _method = method;
     _request = new _HttpClientRequest(method, uri, this);
-    _request.keepAlive = true;
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
   void _onConnectionClosed(Exception e) {
     // Socket is closed either due to an error or due to normal socket close.
     if (e != null) {
       if (_onErrorCallback != null) {
         _onErrorCallback(e);
       }
     }
     _closing = true;
     if (e != null) {
       // Propagate the error to the streams.
       if (_response != null && _response._streamErrorHandler != null) {
         _response._streamErrorHandler(e);
       }
       _responseDone();
     } else {
       // If there was no socket error the socket was closed
       // normally. Indicate closing to the HTTP Parser as there might
       // still be an HTTP error.
       _httpParser.connectionClosed();
     }
   }
 
-  void _onRequestStart(String method, String uri) {
+  void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling.
   }
 
-  void _onResponseStart(int statusCode, String reasonPhrase) {
-    _response._onResponseStart(statusCode, reasonPhrase);
+  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._onHeadersComplete();
   }
 
@@ skipping 225 matching lines @@
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
   Function _onOpen;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Set<_SocketConnection> _activeSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }