Add HTTP/1.0 support and simplify persistent connections handling

tests/standalone/src/io/HttpParserTest.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.
 
 #source("../../../../runtime/bin/http_parser.dart");
 
 class HttpParserTest {
   static void runAllTests() {
     testParseRequest();
     testParseResponse();
     testParseInvalidRequest();
     testParseInvalidResponse();
   }
 
   static void _testParseRequest(String request,
                                 String expectedMethod,
                                 String expectedUri,
                                 [int expectedContentLength = -1,
                                  int expectedBytesReceived = 0,
                                  Map expectedHeaders = null,
                                  bool chunked = false,
                                  bool upgrade = false,
-                                 int unparsedLength = 0]) {
+                                 int unparsedLength = 0,
+                                 bool connectionClose = false,
+                                 String expectedVersion = "1.1"]) {
     _HttpParser httpParser;
     bool headersCompleteCalled;
     bool dataEndCalled;
     String method;
     String uri;
+    String version;
     Map headers;
     int contentLength;
     int bytesReceived;
 
     void reset() {
       httpParser = new _HttpParser();
-      httpParser.requestStart = (m, u) { method = m; uri = u; };
-      httpParser.responseStart = (s, r) { Expect.fail("Expected request"); };
+      httpParser.requestStart = (m, u, v) { method = m; uri = u; version = v; };
+      httpParser.responseStart = (s, r, v) { Expect.fail("Expected request"); };
       httpParser.headerReceived = (f, v) {
         Expect.isFalse(headersCompleteCalled);
         headers[f] = v;
       };
       httpParser.headersComplete = () {
         Expect.isFalse(headersCompleteCalled);
         if (!chunked) {
           Expect.equals(expectedContentLength, httpParser.contentLength);
         } else {
           Expect.equals(-1, httpParser.contentLength);
         }
         if (expectedHeaders != null) {
           expectedHeaders.forEach(
               (String name, String value) =>
                   Expect.equals(value, headers[name]));
         }
         Expect.equals(upgrade, httpParser.upgrade);
+        Expect.equals(connectionClose, !httpParser.persistentConnection);
         headersCompleteCalled = true;
       };
       httpParser.dataReceived = (List<int> data) {
         Expect.isTrue(headersCompleteCalled);
         bytesReceived += data.length;
       };
       httpParser.dataEnd = (close) {
         Expect.isFalse(close);
         dataEndCalled = true;
       };
@@ skipping 19 matching lines @@
         unparsed = writeLength - parsed;
         if (httpParser.upgrade) {
           unparsed += requestData.length - written;
           break;
         } else {
           Expect.equals(0, unparsed);
         }
       }
       Expect.equals(expectedMethod, method);
       Expect.equals(expectedUri, uri);
+      Expect.equals(expectedVersion, version);
       Expect.isTrue(headersCompleteCalled);
       Expect.equals(expectedBytesReceived, bytesReceived);
       if (!upgrade) Expect.isTrue(dataEndCalled);
       if (unparsedLength == 0) {
         Expect.equals(0, unparsed);
       } else {
         Expect.equals(unparsedLength, unparsed);
       }
     }
 
@@ skipping 42 matching lines @@
                                  int expectedStatusCode,
                                  String expectedReasonPhrase,
                                  [int expectedContentLength = -1,
                                   int expectedBytesReceived = 0,
                                   Map expectedHeaders = null,
                                   bool chunked = false,
                                   bool close = false,
                                   String responseToMethod = null,
                                   bool connectionClose = false,
                                   bool upgrade = false,
-                                  int unparsedLength = 0]) {
+                                  int unparsedLength = 0,
+                                  String expectedVersion = "1.1"]) {
     _HttpParser httpParser;
     bool headersCompleteCalled;
     bool dataEndCalled;
     bool dataEndClose;
     int statusCode;
     String reasonPhrase;
+    String version;
     Map headers;
     int contentLength;
     int bytesReceived;
 
     void reset() {
       httpParser = new _HttpParser();
       if (responseToMethod != null) {
         httpParser.responseToMethod = responseToMethod;
       }
-      httpParser.requestStart = (m, u) => Expect.fail("Expected response");
-      httpParser.responseStart = (s, r) {
+      httpParser.requestStart = (m, u, v) => Expect.fail("Expected response");
+      httpParser.responseStart = (s, r, v) {
         statusCode = s;
         reasonPhrase = r;
+        version = v;
       };
       httpParser.headerReceived = (f, v) {
         Expect.isFalse(headersCompleteCalled);
         headers[f] = v;
       };
       httpParser.headersComplete = () {
         Expect.isFalse(headersCompleteCalled);
         if (!chunked && !close) {
           Expect.equals(expectedContentLength, httpParser.contentLength);
         } else {
@@ skipping 37 matching lines @@
         int parsed = httpParser.writeList(requestData, pos, writeLength);
         unparsed = writeLength - parsed;
         if (httpParser.upgrade) {
           unparsed += requestData.length - written;
           break;
         } else {
           Expect.equals(0, unparsed);
         }
       }
       if (close) httpParser.connectionClosed();
+      Expect.equals(expectedVersion, version);
       Expect.equals(expectedStatusCode, statusCode);
       Expect.equals(expectedReasonPhrase, reasonPhrase);
       Expect.isTrue(headersCompleteCalled);
       Expect.equals(expectedBytesReceived, bytesReceived);
       if (!upgrade) {
         Expect.isTrue(dataEndCalled);
         if (close) Expect.isTrue(dataEndClose);
         Expect.equals(dataEndClose, connectionClose);
       }
       if (unparsedLength == 0) {
@@ skipping 63 matching lines @@
 
     request = "HT /index.html HTTP/1.1\r\n\r\n";
     _testParseRequest(request, "HT", "/index.html");
 
     request = "HTT /index.html HTTP/1.1\r\n\r\n";
     _testParseRequest(request, "HTT", "/index.html");
 
     request = "HTTP /index.html HTTP/1.1\r\n\r\n";
     _testParseRequest(request, "HTTP", "/index.html");
 
+    request = "GET / HTTP/1.0\r\n\r\n";
+    _testParseRequest(request, "GET", "/", expectedVersion: "1.0", connectionClose: true);
+
+    request = "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n";
+    _testParseRequest(request, "GET", "/", expectedVersion: "1.0");
+
     request = """
 POST /test HTTP/1.1\r
 AAA: AAA\r
 \r
 """;
     _testParseRequest(request, "POST", "/test");
 
     request = """
 POST /test HTTP/1.1\r
 \r
@@ skipping 53 matching lines @@
 Content-Length: 10\r
 \r
 0123456789""";
     _testParseRequest(request,
                       "POST",
                       "/test",
                       expectedContentLength: 10,
                       expectedBytesReceived: 10);
 
     // Test connection close header.
-    request = """
-GET /test HTTP/1.1\r
-Connection: close\r
-\r\n""";
-    _testParseRequest(request, "GET", "/test");
+    request = "GET /test HTTP/1.1\r\nConnection: close\r\n\r\n";
+    _testParseRequest(request, "GET", "/test", connectionClose: true);
 
     // Test chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
@@ skipping 163 matching lines @@
     response = "HTTP/1.1 100 Continue\r\nContent-Length: 0\r\n\r\n";
     _testParseResponse(response, 100, "Continue", expectedContentLength: 0);
 
     response = "HTTP/1.1 100 Continue\r\nContent-Length: 10\r\n\r\n";
     _testParseResponse(response,
                        100,
                        "Continue",
                        expectedContentLength: 10,
                        expectedBytesReceived: 0);
 
+    response = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: Close\r\n\r\n";
+    _testParseResponse(response,
+                       200,
+                       "OK",
+                       expectedContentLength: 0,
+                       connectionClose: true);
+
+    response = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseResponse(response,
+                       200,
+                       "OK",
+                       expectedContentLength: 0,
+                       expectedVersion: "1.0",
+                       connectionClose: true);
+
+    response = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\nConnection: Keep-Alive\r\n\r\n";
+    _testParseResponse(response, 200, "OK", expectedContentLength: 0, expectedVersion: "1.0");
+
     response = "HTTP/1.1 204 No Content\r\nContent-Length: 11\r\n\r\n";
     _testParseResponse(response,
                        204,
                        "No Content",
                        expectedContentLength: 11,
                        expectedBytesReceived: 0);
 
     response = "HTTP/1.1 304 Not Modified\r\nContent-Length: 12\r\n\r\n";
     _testParseResponse(response,
                        304,
@@ skipping 168 matching lines @@
     _testParseInvalidRequest(request);
 
     request = "GET / TTP/1.1\r\n\r\n";
     _testParseInvalidRequest(request);
 
     request = "GET / HTTP/1.\r\n\r\n";
     _testParseInvalidRequest(request);
 
     request = "GET / HTTP/1.1\r\nKeep-Alive: False\r\nbadheader\r\n\r\n";
     _testParseInvalidRequest(request);
-
-    // Currently no HTTP 1.0 support.
-    request = "GET / HTTP/1.0\r\n\r\n";
-    _testParseInvalidRequest(request);
   }
 
   static void testParseInvalidResponse() {
     String response;
 
     response = "HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
     _testParseInvalidResponse(response);
 
     response = "HTTP/1.1 \r\nContent-Length: 0\r\n\r\n";
     _testParseInvalidResponse(response);
@@ skipping 38 matching lines @@
 0123456789012345678901234567890\r
 0\r\n\r\n""";
     _testParseInvalidResponse(response);
   }
 }
 
 
 void main() {
   HttpParserTest.runAllTests();
 }