Slightly speed up http-parser and http-header-writing.

sdk/lib/io/http_parser.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 // Global constants.
 class _Const {
   // Bytes for "HTTP".
   static const HTTP = const [72, 84, 84, 80];
@@ skipping 229 matching lines @@
 
   // The data that is currently being parsed.
   Uint8List _buffer;
   int _index;
 
   final bool _requestParser;
   int _state;
   int _httpVersionIndex;
   int _messageType;
   int _statusCode = 0;
-  List _method_or_status_code;
-  List _uri_or_reason_phrase;
-  List _headerField;
-  List _headerValue;
+  final List<int> _method = [];
+  final List<int> _uri_or_reason_phrase = [];
+  final List<int> _headerField = [];
+  final List<int> _headerValue = [];
 
   int _httpVersion;
   int _transferLength = -1;
   bool _persistentConnection;
   bool _connectionUpgrade;
   bool _chunked;
 
-  bool _noMessageBody;
-  String _responseToMethod;  // Indicates the method used for the request.
+  bool _noMessageBody = false;
   int _remainingContent = -1;
 
   _HttpHeaders _headers;
 
   // The current incoming connection.
   _HttpIncoming _incoming;
   StreamSubscription _socketSubscription;
   bool _paused = true;
   bool _bodyPaused = false;
   StreamController<_HttpIncoming> _controller;
@@ skipping 94 matching lines @@
         case _State.START:
           if (byte == _Const.HTTP[0]) {
             // Start parsing method or HTTP version.
             _httpVersionIndex = 1;
             _state = _State.METHOD_OR_RESPONSE_HTTP_VERSION;
           } else {
             // Start parsing method.
             if (!_isTokenChar(byte)) {
               throw new HttpException("Invalid request method");
             }
-            _method_or_status_code.add(byte);
+            _method.add(byte);
             if (!_requestParser) {
               throw new HttpException("Invalid response line");
             }
             _state = _State.REQUEST_LINE_METHOD;
           }
           break;
 
         case _State.METHOD_OR_RESPONSE_HTTP_VERSION:
           if (_httpVersionIndex < _Const.HTTP.length &&
               byte == _Const.HTTP[_httpVersionIndex]) {
             // Continue parsing HTTP version.
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP.length &&
                      byte == _CharCode.SLASH) {
             // HTTP/ parsed. As method is a token this cannot be a
             // method anymore.
             _httpVersionIndex++;
             if (_requestParser) {
               throw new HttpException("Invalid request line");
             }
             _state = _State.RESPONSE_HTTP_VERSION;
           } else {
             // Did not parse HTTP version. Expect method instead.
             for (int i = 0; i < _httpVersionIndex; i++) {
-              _method_or_status_code.add(_Const.HTTP[i]);
+              _method.add(_Const.HTTP[i]);
             }
             if (byte == _CharCode.SP) {
               _state = _State.REQUEST_LINE_URI;
             } else {
-              _method_or_status_code.add(byte);
+              _method.add(byte);
               _httpVersion = _HttpVersion.UNDETERMINED;
               if (!_requestParser) {
                 throw new HttpException("Invalid response line");
               }
               _state = _State.REQUEST_LINE_METHOD;
             }
           }
           break;
 
         case _State.RESPONSE_HTTP_VERSION:
@@ skipping 24 matching lines @@
 
         case _State.REQUEST_LINE_METHOD:
           if (byte == _CharCode.SP) {
             _state = _State.REQUEST_LINE_URI;
           } else {
             if (_Const.SEPARATOR_MAP[byte] ||
                 byte == _CharCode.CR ||
                 byte == _CharCode.LF) {
               throw new HttpException("Invalid request method");
             }
-            _method_or_status_code.add(byte);
+            _method.add(byte);
           }
           break;
 
         case _State.REQUEST_LINE_URI:
           if (byte == _CharCode.SP) {
             if (_uri_or_reason_phrase.length == 0) {
               throw new HttpException("Invalid request URI");
             }
             _state = _State.REQUEST_LINE_HTTP_VERSION;
             _httpVersionIndex = 0;
@@ skipping 30 matching lines @@
           break;
 
         case _State.REQUEST_LINE_ENDING:
           _expect(byte, _CharCode.LF);
           _messageType = _MessageType.REQUEST;
           _state = _State.HEADER_START;
           break;
 
         case _State.RESPONSE_LINE_STATUS_CODE:
           if (byte == _CharCode.SP) {
-            if (_method_or_status_code.length != 3) {
-              throw new HttpException("Invalid response status code");
-            }
             _state = _State.RESPONSE_LINE_REASON_PHRASE;
           } else if (byte == _CharCode.CR) {
             // Some HTTP servers does not follow the spec. and send
             // \r\n right after the status code.
             _state = _State.RESPONSE_LINE_ENDING;
           } else {
             if (byte < 0x30 && 0x39 < byte) {
               throw new HttpException("Invalid response status code");
             } else {
-              _method_or_status_code.add(byte);
+              _statusCode = _statusCode * 10 + byte - 0x30;

[Søren Gjesse, 2014/02/20 14:12:18]

As discussed offline, we should keep track of the length, and only allow
precisely 3 digits.

[Anders Johnsen, 2014/02/20 14:46:53]

Done.

             }
           }
           break;
 
         case _State.RESPONSE_LINE_REASON_PHRASE:
           if (byte == _CharCode.CR) {
             _state = _State.RESPONSE_LINE_ENDING;
           } else {
             if (byte == _CharCode.CR || byte == _CharCode.LF) {
               throw new HttpException("Invalid response reason phrase");
             }
             _uri_or_reason_phrase.add(byte);
           }
           break;
 
         case _State.RESPONSE_LINE_ENDING:
           _expect(byte, _CharCode.LF);
           _messageType == _MessageType.RESPONSE;
-          _statusCode = int.parse(
-              new String.fromCharCodes(_method_or_status_code));
           if (_statusCode < 100 || _statusCode > 599) {
             throw new HttpException("Invalid response status code");
           } else {
             // Check whether this response will never have a body.
-            _noMessageBody = _statusCode <= 199 || _statusCode == 204 ||
-                _statusCode == 304;
+            if (_statusCode <= 199 || _statusCode == 204 ||
+                _statusCode == 304) {
+              _noMessageBody = true;
+            }
           }
           _state = _State.HEADER_START;
           break;
 
         case _State.HEADER_START:
           _headers = new _HttpHeaders(version);
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_ENDING;
           } else {
             // Start of new header field.
@@ skipping 36 matching lines @@
           _state = _State.HEADER_VALUE_FOLD_OR_END;
           break;
 
         case _State.HEADER_VALUE_FOLD_OR_END:
           if (byte == _CharCode.SP || byte == _CharCode.HT) {
             _state = _State.HEADER_VALUE_START;
           } else {
             String headerField = new String.fromCharCodes(_headerField);
             String headerValue = new String.fromCharCodes(_headerValue);
             if (headerField == "transfer-encoding" &&
-                       headerValue.toLowerCase() == "chunked") {
+                _caseInsensitiveCompare("chunked".codeUnits, _headerValue)) {
               _chunked = true;
             }
             if (headerField == "connection") {
               List<String> tokens = _tokenizeFieldValue(headerValue);
               for (int i = 0; i < tokens.length; i++) {
-                if (tokens[i].toLowerCase() == "upgrade") {
+                if (_caseInsensitiveCompare("upgrade".codeUnits,
+                                            tokens[i].codeUnits)) {
                   _connectionUpgrade = true;
                 }
                 _headers._add(headerField, tokens[i]);
               }
             } else {
               _headers._add(headerField, headerValue);
             }
             _headerField.clear();
             _headerValue.clear();
 
@@ skipping 24 matching lines @@
               _chunked == false) {
             _transferLength = 0;
           }
           if (_connectionUpgrade) {
             _state = _State.UPGRADED;
             _transferLength = 0;
           }
           _createIncoming(_transferLength);
           if (_requestParser) {
             _incoming.method =
-                new String.fromCharCodes(_method_or_status_code);
+                new String.fromCharCodes(_method);
             _incoming.uri =
                 Uri.parse(
                     new String.fromCharCodes(_uri_or_reason_phrase));
           } else {
             _incoming.statusCode = _statusCode;
             _incoming.reasonPhrase =
                 new String.fromCharCodes(_uri_or_reason_phrase);
           }
-          _method_or_status_code.clear();
+          _method.clear();
           _uri_or_reason_phrase.clear();
           if (_connectionUpgrade) {
             _incoming.upgraded = true;
             _parserCalled = false;
             var tmp = _incoming;
             _closeIncoming();
             _controller.add(tmp);
             return;
           }
           if (_transferLength == 0 ||
-              (_messageType == _MessageType.RESPONSE &&
-               (_noMessageBody || _responseToMethod == "HEAD"))) {
+              (_messageType == _MessageType.RESPONSE && _noMessageBody)) {
             _reset();
             var tmp = _incoming;
             _closeIncoming();
             _controller.add(tmp);
             break;
           } else if (_chunked) {
             _state = _State.CHUNK_SIZE;
             _remainingContent = 0;
           } else if (_transferLength > 0) {
             _remainingContent = _transferLength;
@@ skipping 178 matching lines @@
         return "1.1";
     }
     return null;
   }
 
   int get messageType => _messageType;
   int get transferLength => _transferLength;
   bool get upgrade => _connectionUpgrade && _state == _State.UPGRADED;
   bool get persistentConnection => _persistentConnection;
 
-  void set responseToMethod(String method) { _responseToMethod = method; }
+  void set isHead(bool value) {
+    if (value) _noMessageBody = true;
+  }
 
   _HttpDetachedIncoming detachIncoming() {
     // Simulate detached by marking as upgraded.
     _state = _State.UPGRADED;
     return new _HttpDetachedIncoming(_socketSubscription,
                                      readUnparsedData());
   }
 
   List<int> readUnparsedData() {
     if (_buffer == null) return null;
     if (_index == _buffer.length) return null;
     var result = _buffer.sublist(_index);
     _releaseBuffer();
     return result;
   }
 
   void _reset() {
     if (_state == _State.UPGRADED) return;
     _state = _State.START;
     _messageType = _MessageType.UNDETERMINED;
-    _headerField = new List();
-    _headerValue = new List();
-    _method_or_status_code = new List();
-    _uri_or_reason_phrase = new List();
+    _headerField.clear();
+    _headerValue.clear();
+    _method.clear();
+    _uri_or_reason_phrase.clear();
 
     _statusCode = 0;
 
     _httpVersion = _HttpVersion.UNDETERMINED;
     _transferLength = -1;
     _persistentConnection = false;
     _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
-    _responseToMethod = null;
     _remainingContent = -1;
 
     _headers = null;
   }
 
   void _releaseBuffer() {
     _buffer = null;
     _index = null;
   }
 
@@ skipping 18 matching lines @@
     return tokens;
   }
 
   int _toLowerCase(int byte) {
     final int aCode = "A".codeUnitAt(0);
     final int zCode = "Z".codeUnitAt(0);
     final int delta = "a".codeUnitAt(0) - aCode;
     return (aCode <= byte && byte <= zCode) ? byte + delta : byte;
   }
 
+  // expected should already be lowercase.
+  bool _caseInsensitiveCompare(List<int> expected, List<int> value) {
+    if (expected.length != value.length) return false;
+    for (int i = 0; i < expected.length; i++) {
+      if (expected[i] != _toLowerCase(value[i])) return false;
+    }
+    return true;
+  }
+
   int _expect(int val1, int val2) {
     if (val1 != val2) {
       throw new HttpException("Failed to parse HTTP");
     }
   }
 
   int _expectHexDigit(int byte) {
     if (0x30 <= byte && byte <= 0x39) {
       return byte - 0x30;  // 0 - 9
     } else if (0x41 <= byte && byte <= 0x46) {
@@ skipping 70 matching lines @@
     }
   }
 
   void _reportError(error, [stackTrace]) {
     if (_socketSubscription != null) _socketSubscription.cancel();
     _state = _State.FAILURE;
     _controller.addError(error, stackTrace);
     _controller.close();
   }
 }