Do not use StringBuffer to create strings from individual char

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 152 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 HttpParserException("Invalid request method");
               }
-              _method_or_status_code.addCharCode(byte);
+              _method_or_status_code.add(byte);
               if (!_requestParser) {
                 throw new HttpParserException("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 HttpParserException("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.addCharCode(_Const.HTTP[i]);
+                _method_or_status_code.add(_Const.HTTP[i]);
               }
               if (byte == _CharCode.SP) {
                 _state = _State.REQUEST_LINE_URI;
               } else {
-                _method_or_status_code.addCharCode(byte);
+                _method_or_status_code.add(byte);
                 _httpVersion = _HttpVersion.UNDETERMINED;
                 if (!_requestParser) {
                   throw new HttpParserException("Invalid response line");
                 }
                 _state = _State.REQUEST_LINE_METHOD;
               }
             }
             break;
 
           case _State.RESPONSE_HTTP_VERSION:
@@ skipping 22 matching lines @@
             }
             break;
 
           case _State.REQUEST_LINE_METHOD:
             if (byte == _CharCode.SP) {
               _state = _State.REQUEST_LINE_URI;
             } else {
               if (_Const.SEPARATORS_AND_CR_LF.indexOf(byte) != -1) {
                 throw new HttpParserException("Invalid request method");
               }
-              _method_or_status_code.addCharCode(byte);
+              _method_or_status_code.add(byte);
             }
             break;
 
           case _State.REQUEST_LINE_URI:
             if (byte == _CharCode.SP) {
               if (_uri_or_reason_phrase.length == 0) {
                 throw new HttpParserException("Invalid request URI");
               }
               _state = _State.REQUEST_LINE_HTTP_VERSION;
               _httpVersionIndex = 0;
             } else {
               if (byte == _CharCode.CR || byte == _CharCode.LF) {
                 throw new HttpParserException("Invalid request URI");
               }
-              _uri_or_reason_phrase.addCharCode(byte);
+              _uri_or_reason_phrase.add(byte);
             }
             break;
 
           case _State.REQUEST_LINE_HTTP_VERSION:
             if (_httpVersionIndex < _Const.HTTP1DOT.length) {
               _expect(byte, _Const.HTTP11[_httpVersionIndex]);
               _httpVersionIndex++;
             } else if (_httpVersionIndex == _Const.HTTP1DOT.length) {
               if (byte == _CharCode.ONE) {
                 // HTTP/1.1 parsed.
@@ skipping 10 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(_method_or_status_code.toString(),
-                         _uri_or_reason_phrase.toString(),
+            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 {
               if (byte < 0x30 && 0x39 < byte) {
                 throw new HttpParserException("Invalid response status code");
               } else {
-                _method_or_status_code.addCharCode(byte);
+                _method_or_status_code.add(byte);
               }
             }
             break;
 
           case _State.RESPONSE_LINE_REASON_PHRASE:
             if (byte == _CharCode.CR) {
               if (_uri_or_reason_phrase.length == 0) {
                 throw new HttpParserException("Invalid response reason phrase");
               }
               _state = _State.RESPONSE_LINE_ENDING;
             } else {
               if (byte == _CharCode.CR || byte == _CharCode.LF) {
                 throw new HttpParserException("Invalid response reason phrase");
               }
-              _uri_or_reason_phrase.addCharCode(byte);
+              _uri_or_reason_phrase.add(byte);
             }
             break;
 
           case _State.RESPONSE_LINE_ENDING:
             _expect(byte, _CharCode.LF);
             _messageType == _MessageType.RESPONSE;
-            int statusCode = parseInt(_method_or_status_code.toString());
+            int 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;
             }
             responseStart(statusCode,
-                          _uri_or_reason_phrase.toString(),
+                          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.addCharCode(_toLowerCase(byte));
+              _headerField.add(_toLowerCase(byte));
               _state = _State.HEADER_FIELD;
             }
             break;
 
           case _State.HEADER_FIELD:
             if (byte == _CharCode.COLON) {
               _state = _State.HEADER_VALUE_START;
             } else {
               if (!_isTokenChar(byte)) {
                 throw new HttpParserException("Invalid header field name");
               }
-              _headerField.addCharCode(_toLowerCase(byte));
+              _headerField.add(_toLowerCase(byte));
             }
             break;
 
           case _State.HEADER_VALUE_START:
             if (byte == _CharCode.CR) {
               _state = _State.HEADER_VALUE_FOLDING_OR_ENDING;
             } else if (byte != _CharCode.SP && byte != _CharCode.HT) {
               // Start of new header value.
-              _headerValue.addCharCode(byte);
+              _headerValue.add(byte);
               _state = _State.HEADER_VALUE;
             }
             break;
 
           case _State.HEADER_VALUE:
             if (byte == _CharCode.CR) {
               _state = _State.HEADER_VALUE_FOLDING_OR_ENDING;
             } else {
-              _headerValue.addCharCode(byte);
+              _headerValue.add(byte);
             }
             break;
 
           case _State.HEADER_VALUE_FOLDING_OR_ENDING:
             _expect(byte, _CharCode.LF);
             _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 = _headerField.toString();
-              String headerValue =_headerValue.toString();
+              String headerField = new String.fromCharCodes(_headerField);
+              String headerValue = new String.fromCharCodes(_headerValue);
               bool reportHeader = true;
               if (headerField == "content-length" && !_chunked) {
                 // Ignore the Content-Length header if Transfer-Encoding
                 // is chunked (RFC 2616 section 4.4)
                 _contentLength = parseInt(headerValue);
               } else if (headerField == "connection") {
                 List<String> tokens = _tokenizeFieldValue(headerValue);
                 for (int i = 0; i < tokens.length; i++) {
                   String token = tokens[i].toLowerCase();
                   if (token == "keep-alive") {
@@ skipping 16 matching lines @@
               if (reportHeader) {
                 headerReceived(headerField, headerValue);
               }
               _headerField.clear();
               _headerValue.clear();
 
               if (byte == _CharCode.CR) {
                 _state = _State.HEADER_ENDING;
               } else {
                 // Start of new header field.
-                _headerField.addCharCode(_toLowerCase(byte));
+                _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).
@@ skipping 206 matching lines @@
     return result;
   }
 
   void _bodyEnd() {
     dataEnd(_messageType == _MessageType.RESPONSE && !_persistentConnection);
   }
 
   _reset() {
     _state = _State.START;
     _messageType = _MessageType.UNDETERMINED;
-    _headerField = new StringBuffer();
-    _headerValue = new StringBuffer();
-    _method_or_status_code = new StringBuffer();
-    _uri_or_reason_phrase = new StringBuffer();
+    _headerField = new List();
+    _headerValue = new List();
+    _method_or_status_code = new List();
+    _uri_or_reason_phrase = new List();
 
     _httpVersion = _HttpVersion.UNDETERMINED;
     _contentLength = -1;
     _persistentConnection = false;
     _connectionUpgrade = false;
     _chunked = false;
 
     _noMessageBody = false;
     _responseToMethod = null;
     _remainingContent = null;
@@ skipping 53 matching lines @@
 
   // The data that is currently being parsed.
   List<int> _buffer;
   int _index;
   int _lastIndex;
 
   bool _requestParser;
   int _state;
   int _httpVersionIndex;
   int _messageType;
-  StringBuffer _method_or_status_code;
-  StringBuffer _uri_or_reason_phrase;
-  StringBuffer _headerField;
-  StringBuffer _headerValue;
+  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;
 
   // 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;
 }