Refactor the HTTP parser to collect headers

sdk/lib/io/http_parser.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.
 
 // Global constants.
 class _Const {
   // Bytes for "HTTP".
   static const HTTP = const [72, 84, 84, 80];
   // Bytes for "HTTP/1.".
   static const HTTP1DOT = const [72, 84, 84, 80, 47, 49, 46];
@@ skipping 81 matching lines @@
 }
 
 
 /**
  * HTTP parser which parses the HTTP stream as data is supplied
  * through the [:writeList:] and [:connectionClosed:] methods. As the
  * data is parsed the following callbacks are called:
  *
  *   [:requestStart:]
  *   [:responseStart:]
- *   [:headerReceived:]
- *   [:headersComplete:]
  *   [:dataReceived:]
  *   [:dataEnd:]
  *   [:closed:]
  *   [:error:]
  *
  * If an HTTP parser error occours it is possible to get an exception
  * thrown from the [:writeList:] and [:connectionClosed:] methods if
  * the error callback is not set.
  *
  * The connection upgrades (e.g. switching from HTTP/1.1 to the
  * WebSocket protocol) is handled in a special way. If connection
  * upgrade is specified in the headers, then on the callback to
- * [:headersComplete:] the [:upgrade:] property on the [:HttpParser:]
+ * [:responseStart:] the [:upgrade:] property on the [:HttpParser:]
  * object will be [:true:] indicating that from now on the protocol is
  * not HTTP anymore and no more callbacks will happen, that is
  * [:dataReceived:] and [:dataEnd:] are not called in this case as
  * there is no more HTTP data. After the upgrade the method
  * [:readUnparsedData:] can be used to read any remaining bytes in the
  * HTTP parser which are part of the protocol the connection is
  * upgrading to. These bytes cannot be processed by the HTTP parser
  * and should be handled according to whatever protocol is being
  * upgraded to.
  */
@@ skipping 155 matching lines @@
               }
             } else {
               _expect(byte, _CharCode.CR);
               _state = _State.REQUEST_LINE_ENDING;
             }
             break;
 
           case _State.REQUEST_LINE_ENDING:
             _expect(byte, _CharCode.LF);
             _messageType = _MessageType.REQUEST;
-            requestStart(new String.fromCharCodes(_method_or_status_code),
-                         new String.fromCharCodes(_uri_or_reason_phrase),
-                         version);
-            _method_or_status_code.clear();
-            _uri_or_reason_phrase.clear();
             _state = _State.HEADER_START;
             break;
 
           case _State.RESPONSE_LINE_STATUS_CODE:
             if (byte == _CharCode.SP) {
               if (_method_or_status_code.length != 3) {
                 throw new HttpParserException("Invalid response status code");
               }
               _state = _State.RESPONSE_LINE_REASON_PHRASE;
             } else {
@@ skipping 15 matching lines @@
               if (byte == _CharCode.CR || byte == _CharCode.LF) {
                 throw new HttpParserException("Invalid response reason phrase");
               }
               _uri_or_reason_phrase.add(byte);
             }
             break;
 
           case _State.RESPONSE_LINE_ENDING:
             _expect(byte, _CharCode.LF);
             _messageType == _MessageType.RESPONSE;
-            int statusCode = parseInt(new String.fromCharCodes(_method_or_status_code));
-            if (statusCode < 100 || statusCode > 599) {
+             _statusCode = parseInt(new String.fromCharCodes(_method_or_status_code));
+            if (_statusCode < 100 || _statusCode > 599) {
               throw new HttpParserException("Invalid response status code");
             } else {
               // Check whether this response will never have a body.
               _noMessageBody =
-                  statusCode <= 199 || statusCode == 204 || statusCode == 304;
+                  _statusCode <= 199 || _statusCode == 204 || _statusCode == 304;
             }
-            responseStart(statusCode,
-                          new String.fromCharCodes(_uri_or_reason_phrase),
-                          version);
-            _method_or_status_code.clear();
-            _uri_or_reason_phrase.clear();
             _state = _State.HEADER_START;
             break;
 
           case _State.HEADER_START:
             if (byte == _CharCode.CR) {
               _state = _State.HEADER_ENDING;
             } else {
               // Start of new header field.
               _headerField.add(_toLowerCase(byte));
               _state = _State.HEADER_FIELD;
@@ skipping 49 matching lines @@
                 List<String> tokens = _tokenizeFieldValue(headerValue);
                 for (int i = 0; i < tokens.length; i++) {
                   String token = tokens[i].toLowerCase();
                   if (token == "keep-alive") {
                     _persistentConnection = true;
                   } else if (token == "close") {
                     _persistentConnection = false;
                   } else if (token == "upgrade") {
                     _connectionUpgrade = true;
                   }
-                  headerReceived(headerField, token);
+                  _headers.add(headerField, token);
+
                 }
                 reportHeader = false;
               } else if (headerField == "transfer-encoding" &&
                          headerValue.toLowerCase() == "chunked") {
                 // Ignore the Content-Length header if Transfer-Encoding
                 // is chunked (RFC 2616 section 4.4)
                 _chunked = true;
                 _contentLength = -1;
               }
               if (reportHeader) {
-                headerReceived(headerField, headerValue);
+                _headers.add(headerField, headerValue);
               }
               _headerField.clear();
               _headerValue.clear();
 
               if (byte == _CharCode.CR) {
                 _state = _State.HEADER_ENDING;
               } else {
                 // Start of new header field.
                 _headerField.add(_toLowerCase(byte));
                 _state = _State.HEADER_FIELD;
               }
             }
             break;
 
           case _State.HEADER_ENDING:
             _expect(byte, _CharCode.LF);
             // If a request message has neither Content-Length nor
             // Transfer-Encoding the message must not have a body (RFC
             // 2616 section 4.3).
             if (_messageType == _MessageType.REQUEST &&
                 _contentLength < 0 &&
                 _chunked == false) {
               _contentLength = 0;
             }
             if (_connectionUpgrade) {
               _state = _State.UPGRADED;
-              headersComplete();
+            }
+            if (_requestParser) {
+              requestStart(new String.fromCharCodes(_method_or_status_code),
+                           new String.fromCharCodes(_uri_or_reason_phrase),
+                           version,
+                           _headers);
             } else {
-              headersComplete();
+              responseStart(_statusCode,
+                            new String.fromCharCodes(_uri_or_reason_phrase),
+                            version,
+                            _headers);
+            }
+            _method_or_status_code.clear();
+            _uri_or_reason_phrase.clear();
+            if (!_connectionUpgrade) {
+              _method_or_status_code.clear();
+              _uri_or_reason_phrase.clear();
               if (_chunked) {
                 _state = _State.CHUNK_SIZE;
                 _remainingContent = 0;
               } else if (_contentLength == 0 ||
                          (_messageType == _MessageType.RESPONSE &&
                           (_noMessageBody || _responseToMethod == "HEAD"))) {
                 // If there is no message body get ready to process the
                 // next request.
                 _bodyEnd();
                 _reset();
@@ skipping 200 matching lines @@
 
     _httpVersion = _HttpVersion.UNDETERMINED;
     _contentLength = -1;
     _persistentConnection = false;
     _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
     _responseToMethod = null;
     _remainingContent = null;
+
+    _headers = new _HttpHeaders();
   }
 
   _releaseBuffer() {
     _buffer = null;
     _index = null;
     _lastIndex = null;
   }
 
   bool _isTokenChar(int byte) {
     return byte > 31 && byte < 128 && _Const.SEPARATORS.indexOf(byte) == -1;
@@ skipping 43 matching lines @@
 
   // The data that is currently being parsed.
   List<int> _buffer;
   int _index;
   int _lastIndex;
 
   bool _requestParser;
   int _state;
   int _httpVersionIndex;
   int _messageType;
+  int _statusCode;
   List _method_or_status_code;
   List _uri_or_reason_phrase;
   List _headerField;
   List _headerValue;
 
   int _httpVersion;
   int _contentLength;
   bool _persistentConnection;
   bool _connectionUpgrade;
   bool _chunked;
 
   bool _noMessageBody;
   String _responseToMethod;  // Indicates the method used for the request.
   int _remainingContent;
 
+  _HttpHeaders _headers = new _HttpHeaders();
+
   // Callbacks.
   Function requestStart;
   Function responseStart;
-  Function headerReceived;
-  Function headersComplete;
   Function dataReceived;
   Function dataEnd;
   Function error;
   Function closed;
 }
 
 
 class HttpParserException implements Exception {
   const HttpParserException([String this.message = ""]);
   String toString() => "HttpParserException: $message";
   final String message;
 }