Refactor the close and error handling of HTTP connections

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();
@@ skipping 36 matching lines @@
           expectedHeaders.forEach(
               (String name, String value) =>
                   Expect.equals(value, headers[name]));
         }
         headersCompleteCalled = true;
       };
       httpParser.dataReceived = (List<int> data) {
         Expect.isTrue(headersCompleteCalled);
         bytesReceived += data.length;
       };
-      httpParser.dataEnd = () => dataEndCalled = true;
+      httpParser.dataEnd = (close) {
+        Expect.isFalse(close);
+        dataEndCalled = true;
+      };
 
       headersCompleteCalled = false;
       dataEndCalled = false;
       method = null;
       uri = null;
       headers = new Map();
       bytesReceived = 0;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
@@ skipping 53 matching lines @@
   }
 
   static void _testParseResponse(String response,
                                  int expectedStatusCode,
                                  String expectedReasonPhrase,
                                  [int expectedContentLength = -1,
                                   int expectedBytesReceived = 0,
                                   Map expectedHeaders = null,
                                   bool chunked = false,
                                   bool close = false,
-                                  String responseToMethod = null]) {
+                                  String responseToMethod = null,
+                                  bool connectionClose = false]) {
     _HttpParser httpParser;
     bool headersCompleteCalled;
     bool dataEndCalled;
+    bool dataEndClose;
     int statusCode;
     String reasonPhrase;
     Map headers;
     int contentLength;
     int bytesReceived;
 
     void reset() {
       httpParser = new _HttpParser();
       if (responseToMethod != null) {
         httpParser.responseToMethod = responseToMethod;
@@ skipping 18 matching lines @@
           expectedHeaders.forEach((String name, String value) {
             Expect.equals(value, headers[name]);
           });
         }
         headersCompleteCalled = true;
       };
       httpParser.dataReceived = (List<int> data) {
         Expect.isTrue(headersCompleteCalled);
         bytesReceived += data.length;
       };
-      httpParser.dataEnd = () => dataEndCalled = true;
+      httpParser.dataEnd = (close) {
+        dataEndCalled = true;
+        dataEndClose = close;
+      };
 
       headersCompleteCalled = false;
       dataEndCalled = false;
+      dataEndClose = null;
       statusCode = -1;
       reasonPhrase = null;
       headers = new Map();
       bytesReceived = 0;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
       for (int pos = 0; pos < requestData.length; pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = Math.min(chunkSize, remaining);
         httpParser.writeList(requestData, pos, writeLength);
       }
       if (close) httpParser.connectionClosed();
       Expect.equals(expectedStatusCode, statusCode);
       Expect.equals(expectedReasonPhrase, reasonPhrase);
       Expect.isTrue(headersCompleteCalled);
       Expect.equals(expectedBytesReceived, bytesReceived);
       Expect.isTrue(dataEndCalled);
+      if (close) Expect.isTrue(dataEndClose);
+      Expect.equals(dataEndClose, connectionClose);
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> responseData = response.charCodes();
     testWrite(responseData);
     testWrite(responseData, 10);
     testWrite(responseData, 1);
   }
 
@@ skipping 109 matching lines @@
 POST /test HTTP/1.1\r
 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
+""";
+    _testParseRequest(request, "GET", "/test");
+
     // Test chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
@@ skipping 152 matching lines @@
 1f\r
 0123456789012345678901234567890\r
 0\r\n\r\n""";
     _testParseResponse(response,
                        200,
                        "OK",
                        expectedContentLength: -1,
                        expectedBytesReceived: 57,
                        chunked: true);
 
+    // Test connection close header.
+    response = """
+HTTP/1.1 200 OK\r
+Content-Length: 0\r
+Connection: close\r
+\r
+""";
+    _testParseResponse(response,
+                       200,
+                       "OK",
+                       expectedContentLength: 0,
+                       connectionClose: true);
+
     // Test HTTP response without any transfer length indications
     // where closing the connections indicates end of body.
     response = """
 HTTP/1.1 200 OK\r
 \r
 01234567890123456789012345
 0123456789012345678901234567890
 """;
   _testParseResponse(response,
                      200,
                      "OK",
                      expectedContentLength: -1,
                      expectedBytesReceived: 59,
-                     close: true);
+                     close: true,
+                     connectionClose: true);
   }
 
   static void testParseInvalidRequest() {
     String request;
     request = "GET /\r\n\r\n";
     _testParseInvalidRequest(request);
 
     request = "GET / \r\n\r\n";
     _testParseInvalidRequest(request);
 
@@ skipping 72 matching lines @@
 0123456789012345678901234567890\r
 0\r\n\r\n""";
     _testParseInvalidResponse(response);
   }
 }
 
 
 void main() {
   HttpParserTest.runAllTests();
 }